def draw(self,file=None): """ Trace l'ensemble des lignes de champ passant par les points de départ stockés dans Startpoints. Si un nom de fichier est donné, enregistre la figure dans le fichier mais n'affiche rien à l'écran """ def fun(P,t): B = self.B(P) Bx = B[0] By = B[1] B = np.sqrt(Bx*Bx+By*By) return [Bx/pow(B,4./3.),By/pow(B,4./3.)] t = np.linspace(0,self.k*self.maxint,self.numpoints/2) t2 = - t for P0 in self.startpoints: sol = odeint(fun,P0,t) x = sol[:,0] y = sol[:,1] pl.plot(x,y,'-',color='k') sol = odeint(fun,P0,t2) x = sol[1:,0] y = sol[1:,1] pl.plot(x,y,'-',color='k') pl.arrow(x[1],y[1],x[0]-x[1],y[0]-y[1],color='k') pl.title(self.title) pl.xlim([-self.size,self.size]) pl.ylim([-self.size,self.size]) if file: pl.savefig(file) pl.close() else: pl.show()
def drawVectors(transformed_features, components_, columns, plt, scaled): if not scaled: return plt.axes() # No cheating ;-) num_columns = len(columns) # This funtion will project your *original* feature (columns) # onto your principal component feature-space, so that you can # visualize how "important" each one was in the # multi-dimensional scaling # Scale the principal components by the max value in # the transformed set belonging to that component xvector = components_[0] * max(transformed_features[:,0]) yvector = components_[1] * max(transformed_features[:,1]) ## visualize projections # Sort each column by it's length. These are your *original* # columns, not the principal components. important_features = { columns[i] : math.sqrt(xvector[i]**2 + yvector[i]**2) for i in range(num_columns) } important_features = sorted(zip(important_features.values(), important_features.keys()), reverse=True) print "Features by importance:\n", important_features ax = plt.axes() for i in range(num_columns): # Use an arrow to project each original feature as a # labeled vector on your principal component axes plt.arrow(0, 0, xvector[i], yvector[i], color='b', width=0.0005, head_width=0.02, alpha=0.75) plt.text(xvector[i]*1.2, yvector[i]*1.2, list(columns)[i], color='b', alpha=0.75) return ax
def multiple_optima(gene_number=937, resolution=80, model_restarts=10, seed=10000, max_iters=300, optimize=True, plot=True): """ Show an example of a multimodal error surface for Gaussian process regression. Gene 939 has bimodal behaviour where the noisy mode is higher. """ # Contour over a range of length scales and signal/noise ratios. length_scales = np.linspace(0.1, 60., resolution) log_SNRs = np.linspace(-3., 4., resolution) try:import pods except ImportError: print('pods unavailable, see https://github.com/sods/ods for example datasets') return data = pods.datasets.della_gatta_TRP63_gene_expression(data_set='della_gatta',gene_number=gene_number) # data['Y'] = data['Y'][0::2, :] # data['X'] = data['X'][0::2, :] data['Y'] = data['Y'] - np.mean(data['Y']) lls = GPy.examples.regression._contour_data(data, length_scales, log_SNRs, GPy.kern.RBF) if plot: pb.contour(length_scales, log_SNRs, np.exp(lls), 20, cmap=pb.cm.jet) ax = pb.gca() pb.xlabel('length scale') pb.ylabel('log_10 SNR') xlim = ax.get_xlim() ylim = ax.get_ylim() # Now run a few optimizations models = [] optim_point_x = np.empty(2) optim_point_y = np.empty(2) np.random.seed(seed=seed) for i in range(0, model_restarts): # kern = GPy.kern.RBF(1, variance=np.random.exponential(1.), lengthscale=np.random.exponential(50.)) kern = GPy.kern.RBF(1, variance=np.random.uniform(1e-3, 1), lengthscale=np.random.uniform(5, 50)) m = GPy.models.GPRegression(data['X'], data['Y'], kernel=kern) m.likelihood.variance = np.random.uniform(1e-3, 1) optim_point_x[0] = m.rbf.lengthscale optim_point_y[0] = np.log10(m.rbf.variance) - np.log10(m.likelihood.variance); # optimize if optimize: m.optimize('scg', xtol=1e-6, ftol=1e-6, max_iters=max_iters) optim_point_x[1] = m.rbf.lengthscale optim_point_y[1] = np.log10(m.rbf.variance) - np.log10(m.likelihood.variance); if plot: pb.arrow(optim_point_x[0], optim_point_y[0], optim_point_x[1] - optim_point_x[0], optim_point_y[1] - optim_point_y[0], label=str(i), head_length=1, head_width=0.5, fc='k', ec='k') models.append(m) if plot: ax.set_xlim(xlim) ax.set_ylim(ylim) return m # (models, lls)
def show(model): spiral_x = [] spiral_y = [] model.calculate_spiral(spiral_x, spiral_y) print("sp") figure = plot.figure(1) plot.subplot2grid((1, 3), (0, 2), colspan=1) plot.title('Комплексная амплитуда волны E') plot.xlabel('Re(E)') plot.ylabel('Im(E)') #d = sqrt((spiral_x[1] - spiral_x[0])**2 + (spiral_y[1] - spiral_y[0])**2) d = 0.01 w = d / 3 h_w = w * 2 h_l = d / 3 plot.plot(spiral_x, spiral_y, color='r', linewidth=2) #for i in arange(0, len(spiral_x) - 1, 1): # plot.arrow(spiral_x[i], spiral_y[i], spiral_x[i + 1] - spiral_x[i], spiral_y[i + 1] - spiral_y[i], # width=w, head_width=h_w, head_length=h_l, length_includes_head=True, fc='r', ec='k') plot.arrow(0, 0, spiral_x[-1], spiral_y[-1], width=w*1.5, head_width=h_w*1.5, head_length=h_l*1.5, length_includes_head=True, fc='g', ec='k') plot.grid(True) mx = max(spiral_x) my = max(spiral_y) #plot.xlim([-mx - d, mx + d]) #plot.ylim([-d, my + d]) model.draw(figure)
def plot_pick_and_place_stage(image_rgb, labeled_image, approximated_polygon, unfold_paths, pick_point, place_point, to_file=None, show=True): plot_rgb(image_rgb, show=False) plt.imshow(labeled_image, cmap=plt.cm.RdGy, alpha=0.6) points = [tuple(point[0]) for point in approximated_polygon] # Plot polygon lines for (start_x, start_y), (end_x, end_y) in zip(points, points[1:]+points[0:1]): plt.plot( (start_x, end_x), (start_y, end_y), 'r-', linewidth=2.0 ) # Plot polygon points for x, y in points: plt.plot(x, y, 'ro') #Plot unfold paths for path in unfold_paths: (start_x, start_y), (end_x, end_y) = path plt.plot( (start_x, end_x), (start_y, end_y), 'go-', linewidth=2.0 ) # Plot arrow plt.arrow(pick_point[0], pick_point[1], place_point[0]-pick_point[0], place_point[1]-pick_point[1], head_width=15, head_length=15, fc='blue', ec='blue', lw=5, alpha=0.7) plt.axis('off') if to_file: plt.savefig(to_file, bbox_inches='tight') plt.close() elif show: plt.show()
def plotTSP(path, points,data): # Unpack the primary TSP path and transform it into a list of ordered # coordinates x = []; y = [] x_all=[];y_all=[] for i in path: x.append(points[i][0]) y.append(points[i][1]) for i in range (data.shape[0]): x_all.append(data[i][0]) y_all.append(data[i][1]) plt.plot(x_all, y_all, 'co') # Set a scale for the arrow heads (there should be a reasonable default for this, WTF?) a_scale = float(max(x))/float(100) # Draw the primary path for the TSP problem plt.arrow(x[-2], y[-2], (x[0] - x[-2]), (y[0] - y[-2]), head_width = 10*a_scale, color ='g', length_includes_head=True) for i in range(0,len(x)-2): plt.arrow(x[i], y[i], (x[i+1] - x[i]), (y[i+1] - y[i]), head_width = 10*a_scale, color = 'r', length_includes_head = True) #Set axis too slitghtly larger than the set of x and y plt.xlim(min(x_all)*1.1, max(x_all)*1.1) plt.ylim(min(y_all)*1.1, max(y_all)*1.1) plt.show()
def draw_arrow(pair, alpha=alpha, ec=ec, labelcolor=labelcolor): # set the length of the arrow if display == 'length': length = max_head_length + data[pair]/sf*(max_arrow_length - max_head_length) else: length = max_arrow_length # set the transparency of the arrow if display == 'alph': alpha = min(data[pair]/sf, alpha) else: alpha = alpha # set the width of the arrow if display == 'width': scale = data[pair]/sf width = max_arrow_width*scale head_width = max_head_width*scale head_length = max_head_length*scale else: width = max_arrow_width head_width = max_head_width head_length = max_head_length fc = colors[pair] ec = ec or fc x_scale, y_scale = deltas[pair] x_pos, y_pos = positions[pair] plt.arrow(x_pos, y_pos, x_scale*length, y_scale*length, fc=fc, ec=ec, alpha=alpha, width=width, head_width=head_width, head_length=head_length, **arrow_params) # figure out coordinates for text # if drawing relative to base: x and y are same as for arrow # dx and dy are one arrow width left and up # need to rotate based on direction of arrow, use x_scale and y_scale # as sin x and cos x? sx, cx = y_scale, x_scale where = label_positions[pair] if where == 'left': orig_position = 3*np.array([[max_arrow_width, max_arrow_width]]) elif where == 'absolute': orig_position = np.array([[max_arrow_length/2.0, 3*max_arrow_width]]) elif where == 'right': orig_position = np.array([[length - 3*max_arrow_width, 3*max_arrow_width]]) elif where == 'center': orig_position = np.array([[length/2.0, 3*max_arrow_width]]) else: raise ValueError("Got unknown position parameter %s" % where) M = np.array([[cx, sx], [-sx, cx]]) coords = np.dot(orig_position, M) + [[x_pos, y_pos]] x, y = np.ravel(coords) orig_label = rate_labels[pair] label = '$%s_{_{\mathrm{%s}}}$' % (orig_label[0], orig_label[1:]) plt.text(x, y, label, size=label_text_size, ha='center', va='center', color=labelcolor or fc)
def compareGraphs(imgOld, imgNew, POI, V): plt.imshow(imgNew,cmap = 'gray') # plt.scatter(POI[:,0,1],POI[:,0,0]) for i in range(len(POI)): plt.arrow(POI[i,0,1],POI[i,0,0],V[i,1]*1,V[i,0]*1, color = 'red') # plt.arrow(POI[:,0,0],POI[:,0,1],0,-5) plt.show()
def animate(generation): chromosome = ts_ga.generation_fittest[generation] ax.clear() x, y = [], [] for city_id, point in city_points.items(): x.append(point[0]) y.append(point[1]) ax.plot(x, y, marker='s', linestyle='', label='cities', alpha=0.6) # plot optimal route chrom_city_ids = ts_ga.translator.translate_chromosome(chromosome) dist = round(ts_ga.calc_distance(chromosome), 2) ax.set_title("generation " + str(generation) + "\ndistance = " + str(dist)) for i, start_city_id in enumerate(chrom_city_ids): end_city_idx = i + 1 if end_city_idx == num_cities: # distance from last city to first end_city_idx = 0 end_city_id = chrom_city_ids[end_city_idx] x1, y1 = city_points[start_city_id] x2, y2 = city_points[end_city_id] mid_x = (x2 - x1) / 2 + x1 mid_y = (y2 - y1) / 2 + y1 plt.arrow(x1, y1, x2 - x1, y2 - y1, head_width=1.5, fc='k', ec='k', alpha=0.7, linestyle='dotted', length_includes_head=True) plt.text(mid_x, mid_y, str(i + 1))
def _fillPolarPlot(self, ax, drifter_id=0, printInfo=False): max_r = 0 observedParticles = self.observeParticles()[:, drifter_id, :] if printInfo: print("observedParticles: \n" +str(observedParticles)) for p in range(self.numParticles): u, v = observedParticles[p,0], observedParticles[p,1] r = np.sqrt(u**2 + v**2) max_r = max(max_r, r) theta = np.arctan(v/u) if (u < 0): theta += np.pi arr1 = plt.arrow(theta, 0, 0, r, alpha = 0.5, \ length_includes_head=True, \ edgecolor = 'green', facecolor = 'green', zorder = 5) obs_u = self.observeTrueState()[drifter_id, 2] obs_v = self.observeTrueState()[drifter_id, 3] if printInfo: print("observedTrueState: " + str((obs_u, obs_v))) obs_r = np.sqrt(obs_u**2 + obs_v**2) max_r = max(max_r, obs_r) obs_theta = np.arctan(obs_v/obs_u) if (obs_u < 0): obs_theta += np.pi arr1 = plt.arrow(obs_theta, 0, 0, obs_r, alpha = 0.5,\ length_includes_head=True, \ edgecolor = 'red', facecolor = 'red', zorder = 5) #ax.plot(theta, r, color='#ee8d18', lw=3) ax.set_rmax(max_r*1.2) plt.grid(True) plt.title("Observations from drifter " + str(drifter_id))
def draw_experiment_data(experiment, viewport=None, estimate=True, camera=True, truth=True, cov=False): with open('/home/cristi/Dropbox/FIRM/Experiments/iser_trials/experiment_data_{}.txt'.format(experiment), 'r') as fin: for line in fin: line = line.strip() if line.startswith('#'): pass elif line: data = dict(eval(line)) if data.has_key('opti') and data.has_key('filter'): plot_data = [] if estimate: plot_data.append((data['x'], (1.0, 0, 0))) if camera: plot_data.append((data['filter'], (1, 1, 0))) if truth: plot_data.append((data['opti'], (0, 1, 0))) # TODO: colors 'g' for (x, y, yaw,), col in plot_data: plt.arrow(x, y, 0.1*np.cos(yaw), 0.1*np.sin(yaw), hold=True, color=col) if cov: viewport.add_patch( Mission.covariance_ellipse( data['x'][:2], np.diag(data['cov'][:2]), color='b', fill=False, lw=1, zorder=0))
def draw_arrows(pos, side, direction, om, last=False): ARROW_WIDTH = 0.04 FONTSIZE = 20 alpha = 0.3 if last else None dx, dy = 0.5, 1 npos = pos + 1 if isinstance(om, int): txt = m(r'\omega_' + str(om)) else: txt = m(r'k_{' + str(om) + r'}') if (side == 1 and direction == 'in') or (side == 0 and direction == 'out'): txt = r'$-' + txt[1:] else: txt = r'$+' + txt[1:] if direction == 'in': if side == 1: dx *= -1 plt.arrow(side - dx, npos - dy, dx, dy, width=ARROW_WIDTH, length_includes_head=True, lw=0) plt.text(side - dx, npos - dy / 2., txt, fontsize=FONTSIZE, horizontalalignment='center') else: if side == 1: dx *= -1 plt.arrow(side, npos, -dx, dy, width=ARROW_WIDTH, length_includes_head=True, lw=0, alpha=alpha) plt.text(side - dx, npos + dy / 3., txt, fontsize=FONTSIZE, horizontalalignment='center')
def plot_state(self, i, history): plt.clf() ax = plt.gca() w = float(self.width + 1) h = float(self.height + 1) minw = np.min(self.internal_weights) maxw = np.max(self.internal_weights) diffw = maxw - minw for n, neuron in enumerate(self.neurons): x, y = self.neuron_position(n) line_y = -history[i - 100:i:4, n] #line_y = history[max(i - 20, 0):i, n] + .25 line_x = np.arange(len(line_y)) / 50.0 #line_x = np.arange(len(line_y)) / 40.0 line = mlines.Line2D((line_x + x + .75) / w, 1 - (line_y + y + 1) / h) ax.add_line(line) k = .2 for dx, dy in DIRECTIONS: weight = self.internal_weights[self.neuron_index(x, y), self.neuron_index((x + dx) % self.width, (y + dy) % self.height)] plt.arrow( (1 + x + (1 - k) / 2 * dx) / w, 1 - (1 + y + (1 - k) / 2 * dy) / h, (k * dx) / w, -(k * dy) / h, width=.0002, color=str(weight / maxw), ) plt.draw()
def plot2d(self,ix=0,iy=1,clf=True): """ Generates a 2-dimensional plot of the data set and principle components using matplotlib. ix specifies which p-dimension to put on the x-axis of the plot and iy specifies which to put on the y-axis (0-indexed) """ import matplotlib.pyplot as plt x,y=self.N[:,ix],self.N[:,iy] if clf: plt.clf() plt.scatter(x,y) vals,evs=self.getEigensystem() #evx,evy=evs[:,ix],evs[:,iy] xl,xu=plt.xlim() yl,yu=plt.ylim() dx,dy=(xu-xl),(yu-yl) for val,vec,c in zip(vals,evs.T,self._colors): plt.arrow(0,0,val*vec[ix],val*vec[iy],head_width=0.05*(dx*dy/4)**0.5,fc=c,ec=c) #plt.arrow(0,0,vals[ix]*evs[ix,ix],vals[ix]*evs[iy,ix],head_width=0.05*(dx*dy/4)**0.5,fc='g',ec='g') #plt.arrow(0,0,vals[iy]*evs[ix,iy],vals[iy]*evs[iy,iy],head_width=0.05*(dx*dy/4)**0.5,fc='r',ec='r') if self.names is not None: plt.xlabel('$'+self.names[ix]+'/\\sigma$') plt.ylabel('$'+self.names[iy]+'/\\sigma$')
def Velocities_2D(n): dim = 2 fig = plt.figure(dim, figsize=(8, 8), facecolor='white') fig.clf() xmin, xmax, ymin, ymax = 1000, -1000, 1000, -1000 e = .5 for k in range((2*n+1)**dim): v = pylbm.stencil.Velocity(dim = dim, num = k) x = v.vx y = v.vy xmin = min(xmin, x) xmax = max(xmax, x) ymin = min(ymin, y) ymax = max(ymax, y) couleur_texte = 0. couleur_trait = 0.5 plt.text(x, y, str(v.num), color=[couleur_texte]*3, horizontalalignment='center',verticalalignment='center', fontsize=15) for x in range(xmin, xmax+1): plt.plot([x, x], [ymin, ymax], ':', color=[couleur_trait]*3) for y in range(ymin, ymax+1): plt.plot([xmin, xmax], [y, y], ':', color=[couleur_trait]*3) plt.text(0., ymax+2*e, "Velocities numbering {0:1d}D".format(dim),fontsize=20, verticalalignment='center', horizontalalignment='center', color='b') plt.arrow(xmin-e, ymin-e, 1, 0, head_width=0.05*dim, head_length=0.1, fc='b', ec='b') plt.arrow(xmin-e, ymin-e, 0, 1, head_width=0.05*dim, head_length=0.1, fc='b', ec='b') plt.text(xmin-e+.5, ymin-1.5*e, 'x', color='b', verticalalignment='center', horizontalalignment='center') plt.text(xmin-1.5*e, ymin-e+.5, 'y', color='b', verticalalignment='center', horizontalalignment='center') plt.axis('off') plt.xlim(xmin-2*e, xmax+2*e) plt.ylim(ymin-2*e, ymax+2*e) plt.draw()
def iaplot(Ylist, Xlist = [], arrows_list = [],text_list = [], ylabel='y', xlabel='x', title='',colors = 'rgbmycrgbm',shapes = '----------', axis = 'tight'): import numpy as np import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt import ia636 if isinstance(Ylist, np.ndarray): Ylist = [Ylist] if Xlist == []: Xlist = [np.arange(len(i)) for i in Ylist] if isinstance(Xlist, np.ndarray): Xlist = [Xlist] fig = plt.figure() plt.ylabel(ylabel) plt.xlabel(xlabel) plt.title(title) for x,y, c,s in zip(Xlist, Ylist,colors[:len(Xlist)],shapes[:len(Xlist)]): plt.plot(x,y, c+s,markersize=9) for arrow in arrows_list: plt.arrow(arrow[0], arrow[1], arrow[2], arrow[3], fc="k", ec="k", head_width=0.15, head_length=0.2 ) for text in text_list: plt.annotate(text[0],xy=(text[1], text[2]), xycoords='data',xytext=(text[1], text[2]), textcoords='data',) plt.grid() plt.axis(axis) return ia636.iafig2img(fig)
def plotarrows(): COORDINATES = np.load(savebase + savefilename + '.npy') plt.figure() plt.rc('text', usetex=True) ypmin = 0 ypmax = 100 xpmin = 0 xpmax = 70 plt.xlim(xmin=xpmin, xmax=xpmax) plt.ylim(ymin=ypmin, ymax=ypmax) for i in range(0,len(COORDINATES)-1): lw = 0.1+COORDINATES[i,2]*100. if i%21==0: plt.arrow(COORDINATES[i,0], COORDINATES[i,1], (COORDINATES[i+1,0] - COORDINATES[i,0]), (COORDINATES[i+1,1] - COORDINATES[i,1]), fc="k", ec="k", head_width=1.5, head_length=1, linewidth=lw) else: plt.arrow(COORDINATES[i,0], COORDINATES[i,1], (COORDINATES[i+1,0] - COORDINATES[i,0]), (COORDINATES[i+1,1] - COORDINATES[i,1]), linewidth=lw) plt.gca().set_aspect('equal') plt.title('Trajectory over time: ' + str(len(COORDINATES)*10)) plt.xlabel('$x/r_g$') plt.ylabel('$z/r_g$') plt.show() plt.savefig(figbase+savefilename, bbox_inches='tight')
def drawArrow(x=.5, y=.7, dx=.2, dy=-0.3, fc="k", ec="k"): """wrapping the matplotlib.pyplot.arrow function """ # plt.arrow( x, y, dx, dy, **kwargs ) head_width = (dx**2 +dy**2)**.5 *0.05 head_length = (dx**2 +dy**2)**.5 *0.1 plt.arrow(x, y, dx, dy, fc=fc, ec=ec, head_width=head_width, head_length=head_length)
def plot_loop(): figure(figsize=(10.5, 4.5), frameon=False) gca().axis("off") xlim(0.5, 3.5) ylim(0.7, 2.2) arrow_params = {"head_length": 0.08, "head_width": 0.1, "ec": "k", "fc": "k"} text_params = {"fontsize": 25, "horizontalalignment": "center", "verticalalignment": "center"} arrow(0.5, 1, 0.85, 0, **arrow_params) # EX_A arrow(1.5, 1, 0.425, 0.736, **arrow_params) # v1 arrow(2.04, 1.82, 0.42, -0.72, **arrow_params) # v2 arrow(2.4, 1, -0.75, 0, **arrow_params) # v3 arrow(2.6, 1, 0.75, 0, **arrow_params) # reaction labels text(0.9, 1.15, "EX_A", **text_params) text(1.6, 1.5, r"v$_1$", **text_params) text(2.4, 1.5, r"v$_2$", **text_params) text(2, 0.85, r"v$_3$", **text_params) text(2.9, 1.15, "DM_C", **text_params) # metabolite labels scatter(1.5, 1, s=250, color='#c994c7') text(1.5, 0.9, "A", **text_params) scatter(2, 1.84, s=250, color='#c994c7') text(2, 1.95, "B", **text_params) scatter(2.5, 1, s=250, color='#c994c7') text(2.5, 0.9, "C", **text_params)
def show(self): '''バイプロット表示関数 ''' #: 各国のプロット for i in xrange(len(self.biblot_data)): x, y = self.biblot_data[i] data_name = self.data_name[i].decode("utf-8") if data_name != self.JAPAN_NAME: plt.text(x, y, data_name, ha='center', va='center', fontsize=18) else: plt.text(x, y, data_name, ha='center', va='center', fontsize=18, color="r") #: 因子負荷量のプロット for i in xrange(len(self.LIST_DATA_COLUMN)): x = self.pca_comp[0, i] * self.pca_score[0] y = self.pca_comp[1, i] * self.pca_score[1] plt.arrow(0, 0, x, y, color='r', width=0.002, head_width=0.04) plt.text(x * self.TEXT_MOVE_RATE, y * self.TEXT_MOVE_RATE, self.LIST_DATA_COLUMN[i], color='b', ha='center', va='center', fontsize=18) #: 画像表示系の設定 self._set_canvas() plt.show()
def plot_all(): pylab.axes() x = [x0, x1, x2, x3, x4, x5, x6, x7, x8] y = [y0, y1, y2, y3, y4, y5, y6, y7, y8] plt.title('Retroreflective Sphere') plt.plot(x, y) plt.xlim(-0.1, 0.1) plt.ylim(-0.13, 0.1) plt.xlabel(u"[m]") plt.ylabel(u"[m]") point_num = 0 for i, j in izip(x, y): if withCoords: plt.annotate("M%s\n" % point_num + "[%2.3e," % i + "%2.3e]" % j, xy=(i, j)) point_num += 1 if withArrows: for i in xrange(len(x) - 1): plt.arrow(x[i], y[i], x[i + 1] - x[i], y[i + 1] - y[i], head_width=0.005, head_length=0.004, fc="k", ec="k", width=0.00003)
def draw(self, show_normal=False, color='green'): for i, segment in enumerate(self.segments): plt.plot(segment[:, 0], segment[:, 1], color=color) if show_normal: normal = math2d.normal(segment) center = math2d.center(segment) plt.arrow(center[0], center[1], normal[0], normal[1], width=0.01, color=color)
def visual_addition(vectors): x = 0 y = 0 for v in vectors: plt.arrow(x, y, v[0], v[1], head_width=0.1, head_length=0.1) x += v[0] y += v[1]
def plotarrows(): COORDINATES = np.load(savefilename) plt.figure() plt.rc('text', usetex=True) ypmin = 0 ypmax = 100 xpmin = 0 xpmax = 70 plt.xlim(xmin=xpmin, xmax=xpmax) plt.ylim(ymin=ypmin, ymax=ypmax) for i in range(0,len(COORDINATES)-1): lw = 1+COORDINATES[i,2]*10. if i%2==0: plt.arrow(COORDINATES[i,0], COORDINATES[i,1], (COORDINATES[i+1,0] - COORDINATES[i,0]), (COORDINATES[i+1,1] - COORDINATES[i,1]), fc="k", ec="k", head_width=1.5, head_length=1, linewidth=lw) else: plt.arrow(COORDINATES[i,0], COORDINATES[i,1], (COORDINATES[i+1,0] - COORDINATES[i,0]), (COORDINATES[i+1,1] - COORDINATES[i,1]), linewidth=lw) plt.gca().set_aspect('equal') plt.title('Trajectory over time: ' + str(len(COORDINATES)*100)) plt.xlabel('$r/r_g$') plt.ylabel('$r/r_g$') plt.show() plt.savefig('/Users/Anton/Dropbox/Aleksander/Figures/simavg0070-0134/particles/particle_'+ str(gSTART_INDEX) +'_'+ str(gSTART_x)+'_'+str(gSTART_y), bbox_inches='tight')
def plotArrow(p0, p1, headWidth=.1): dx = p1[0] - p0[0] dy = p1[1] - p0[1] plt.arrow(p0[0], p0[1], dx, dy, head_width=headWidth, length_includes_head = True)
def open_spline_chain_main(): #x = [0, 3, -20, -10] #y = [0, 30, -5, -3] #th = [np.pi/2., np.pi, -np.pi/2., 0.] x = np.cos(np.deg2rad(135.))*np.array([-10., 1., 50.]) y = np.sin(np.deg2rad(135.))*np.array([-10., 1., 50.]) th = [np.deg2rad(135.), np.deg2rad(135.), np.deg2rad(135.)] X = np.column_stack((x, y)) # Random desired discretization along the splines for demonstration purposes Ns = np.random.random_integers(100., 200., (X.shape[0]-1,)) # one less spline than waypoints. sx, sy, sth, length, u, coeffs = PiazziSpline.splineOpenChain(X, th, Ns) plt.plot(sx, sy, 'k-', linewidth=2.0) #test_x = 3.0 #test_y = 30.01 test_x = 0.013 test_y = 0.008 u_star, closest, distance = closestPointOnSpline2D(length, sx, sy, test_x, test_y, u, coeffs, guess=None) print "closest X = {:.3f}, {:.3f}, u* = {}".format(closest[0], closest[1], u_star) # Figure out the LOS controller using this example tangent_th = np.interp(u_star, u, sth) print "tangent th = {:.3f} deg".format(tangent_th*180.0/np.pi) lookAhead = 0.1 # how far forward in u lookaheadState = splineToEuclidean2D(coeffs, min(u_star + lookAhead, u[-1])) print "lookahead X = {:.3f}, {:.3f}".format(lookaheadState[0], lookaheadState[1]) dx_global = lookaheadState[0] - closest[0] dy_global = lookaheadState[1] - closest[1] print "dx_global = {:.3f}, dy_global = {:.3f}".format(dx_global, dy_global) dx_frenet = dx_global*math.cos(tangent_th) + dy_global*math.sin(tangent_th) dy_frenet = dx_global*math.sin(tangent_th) - dy_global*math.cos(tangent_th) print "y error = {:.3f}, dx_frenet = {:.3f}, dy_frenet = {:.3f}".format(distance, dx_frenet, dy_frenet) # need sign of distance to spline to change # look at sign of cross product to determine "handed-ness" angle_from_closest_to_test = math.atan2(closest[1] - test_y, closest[0] - test_x) print "angle from closest to test = {:.3f} deg".format(angle_from_closest_to_test*180./np.pi) sign_test = np.cross([math.cos(tangent_th), math.sin(tangent_th)], [math.cos(angle_from_closest_to_test), math.sin(angle_from_closest_to_test)]) distance *= np.sign(sign_test) print "distance to spline after sign update = {:.3f}".format(distance) # resulting triangle relative_angle = math.atan2((distance - dy_frenet), dx_frenet) global_angle = tangent_th + relative_angle print "relative angle = {:.3f} deg, global angle = {:.3f} deg".format(relative_angle*180./np.pi, global_angle*180./np.pi) # plot plt.plot(test_x, test_y, 'r+', markersize=12., markeredgewidth=2.0) plt.plot(closest[0], closest[1], 'gx', markersize=12., markeredgewidth=2.0) plt.plot(lookaheadState[0], lookaheadState[1], 'go', markersize=12., markeredgewidth=2.0) result_line = np.array([[test_x, test_y], closest]) lookAhead_line = np.array([closest, lookaheadState]) plt.plot(result_line[:, 0], result_line[:, 1], 'b-') plt.plot(lookAhead_line[:, 0], lookAhead_line[:, 1], 'g-') plt.arrow(closest[0], closest[1], 10.*math.cos(tangent_th), 10.*math.sin(tangent_th), linestyle='dashed') d = math.sqrt(math.pow(lookaheadState[0] - test_x, 2) + math.pow(lookaheadState[1] - test_y, 2)) plt.arrow(test_x, test_y, d*math.cos(global_angle), d*math.sin(global_angle), linestyle='dotted') plt.axis('equal') plt.title("length = {:.2f}, u = {:.4f}, distance = {:.2f}".format(length[-1], u_star, distance)) plt.show()
def matrix2png(matrixname, savedfolder, xlim, ylim, arrows): matrix = open(matrixname, 'r').readlines() matrix = [i.split() for i in matrix] matrix = [[float(j) for j in i] for i in matrix] matrix_t = transposed(matrix) y = [] for col in range(0,len(matrix_t)): y.append(matrix_t[col]) longitud = len(y) for i in range(0, len(y[1])): for j in range(0, longitud/2): plt.plot(y[j*2][i],y[j*2+1][i],'o') for a in arrows: ao = a[0] - 1 ai = a[1] - 1 plt.arrow(y[ao*2][i], y[ao*2+1][i], y[ai*2][i]-y[ao*2][i],y[ai*2+1][i]-y[ao*2+1][i]) #Limites de los ejes plt.xlim(xlim[0], xlim[1]) plt.ylim(ylim[0], ylim[1]) plt.savefig(savedfolder + str(i).zfill(5) + '.png') plt.clf() plt.close()
def phaseportrait(fs,inits,t=(-5,5),n=100, head_width = 0.13, head_length = 0.3, **kw): """ plots phase portrait of the differential equation (\dot x,\dot y)=fs(x,y) f -- must accept an array of X and t=0, and return a 2D array of \dot y and \dot x inits -- list of vectors representing inital conditions t -- time interval n -- number of points Example ======= from itertools import product phaseportrait(lambda X, t=0: array([X[0],2*X[1]]), product(linspace(-4,4,15),linspace(-4,4,15)), [-2,0.3], n=20) """ assert(t[0]<t[1] and t[1]>0) X=[] Y=[] for x0 in inits: x0=np.array(x0) if t[0]<0: segments=[np.linspace(0,t[0],n),np.linspace(0,t[1],n)] else: segments=[np.linspace(t[0],t[1],2*n)] for s in segments: points=integrate.odeint(fs,x0,s) for i,Z in enumerate([X,Y]): Z.extend(points[:,i]) Z.append(None) direction = fs(x0) direction = direction / scipy.linalg.norm(direction) * 0.01 plt.arrow(x0[0]-direction[0],x0[1]-direction[1],direction[0],direction[1], head_width=head_width, head_length=head_length, lw=0.0, **kw) plt.plot(X,Y,**kw)
def plotWindVectorsOnMap(date, showIt=True): from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt import wUUtils as Util # setup Lambert Conformal basemap. m = Basemap(width=3200000,height=2500000,projection='lcc', resolution='i',lat_1=45.,lat_0=43.6,lon_0=-80.) # draw coastlines. m.drawcoastlines() m.drawcountries() m.drawstates() # draw a boundary around the map, fill the background. # this background will end up being the ocean color, since # the continents will be drawn on top. m.drawmapboundary(fill_color='aqua') # fill continents, set lake color same as ocean color. m.fillcontinents(color='wheat',lake_color='aqua') # get city locations (Toronto, Montreal, Detroit) cityName = Util.getStationList() lon, lat = Util.getStationLonLat(cityName) # convert to map projection coords. # Note that lon,lat can be scalars, lists or numpy arrays. xpt,ypt = m(lon,lat) m.plot(xpt,ypt,'bo') # plot a blue dot there # compute wind vectors windX = Util.loadDailyVariable(cityName, date, 'WindMeanX') windY = Util.loadDailyVariable(cityName, date, 'WindMeanY') for icity in range(len(cityName)): stretch = 20000 dx, dy = stretch*windX[icity], stretch*windY[icity] plt.arrow(xpt[icity],ypt[icity],dx,dy,color='r',width=12000,head_length=40000,head_width=40000) plt.text(xpt[icity]+30000,ypt[icity]+20000,cityName[icity], size='large') plt.title("Daily-mean wind: " + date) if showIt: plt.show()
def display_velocity( q , p ,mu , mu2 = None): W = 5*SIGMA res = 30 N_nodes = res**2 store = np.outer( np.linspace(-W,W , res), np.ones(res) ) nodes = np.zeros( [N_nodes , DIM] ) nodes[:,0] = np.reshape( store , N_nodes ) nodes[:,1] = np.reshape( store.T , N_nodes ) K,DK,D2K,D3K = jpf.derivatives_of_kernel(nodes , q) vel_field = np.einsum('ijab,jb->ia',K,p) - np.einsum('ijabc,jbc->ia',DK,mu) if mu2 != None: vel_field = vel_field + np.einsum('ijabcd,jbcd->ia',D2K,mu2) U = vel_field[:,0] V = vel_field[:,1] plt.figure() plt.quiver( nodes[:,0] , nodes[:,1] , U , V , scale=10 ) plt.plot(q[:,0],q[:,1],'ro') for i in range(0,N): if np.linalg.norm(p[i]) < 1e-4: continue plt.arrow(q[i,0], q[i,1], p[i,0], p[i,1], head_width=0.1, head_length=0.2, lw = 4.0, fc='b', ec='b') plt.arrow(q[i,0], q[i,1], p[i,0], p[i,1], head_width=0.1, head_length=0.2, lw = 2.0, fc='w', ec='w') plt.axis('equal') plt.axis([- W, W,- W, W ]) return plt.gcf()
# -*- coding: utf-8 -*- """ Listing 2-13. 2DROTCIRCLE2 """ import matplotlib.pyplot as plt import numpy as np plt.axis([-10, 150, 100, -10]) plt.axis('on') plt.grid(True) #--------------------------------------------------------------------------axes plt.arrow(0, 0, 40, 0, head_length=4, head_width=2, color='b') plt.arrow(0, 0, 0, 40, head_length=4, head_width=2, color='b') plt.text(30, -3, 'Xg', color='b') plt.text(-8, 34, 'Yg', color='b') xc = 80 #--------------------center of rotation yc = 30 plt.plot([xc - 50, xc + 60], [yc, yc], linewidth=1, color='grey') #----X plt.plot([xc, xc], [yc - 35, yc + 60], linewidth=1, color='grey') #----Y plt.text(xc + 50, yc - 2, 'X') plt.text(xc - 5, yc + 55, 'Y') plt.scatter(xc, yc, s=20, color='k') #---plot center of rotation plt.text(xc - 5, yc - 3, 'c') #-----------------------------------------------------define rotation matrix Rz def rotz(xp, yp, rz):
def main(scene_idx): scene_name = Test_Scenes[scene_idx] #scene_file_addr = '/home/reza/Datasets/GibsonEnv/my_code/visual_servoing/sample_image_pairs_test/{}'.format(scene_name) scene_file_addr = '/home/reza/Datasets/GibsonEnv/my_code/visual_servoing/sample_image_pairs_test_longer_dist/{}'.format( scene_name) #scene_name = Train_Scenes[scene_idx] #scene_file_addr = '/home/reza/Datasets/GibsonEnv/my_code/visual_servoing/sample_image_pairs_train/{}'.format(scene_name) create_folder(scene_file_addr) ## rrt functions ## first figure out how to sample points from rrt graph rrt_directory = '/home/reza/Datasets/GibsonEnv/gibson/assets/dataset/{}_for_rrt'.format( scene_name) path_finder = rrt.PathFinder(rrt_directory) path_finder.load() num_nodes = len(path_finder.nodes_x) free = cv2.imread( '/home/reza/Datasets/GibsonEnv/gibson/assets/dataset/{}_for_rrt/free.png' .format(scene_name), 0) ## GibsonEnv setup config_file = os.path.join( '/home/reza/Datasets/GibsonEnv/my_code/CVPR_workshop', 'env_yamls', '{}_navigate.yaml'.format(scene_name)) env = HuskyNavigateEnv(config=config_file, gpu_count=1) obs = env.reset( ) ## this line is important otherwise there will be an error like 'AttributeError: 'HuskyNavigateEnv' object has no attribute 'potential'' def get_obs(current_pose): pos, orn = func_pose2posAndorn(current_pose, mapper_scene2z[scene_name]) env.robot.reset_new_pose(pos, orn) obs, _, _, _ = env.step(4) obs_rgb = obs['rgb_filled'] obs_depth = obs['depth'] return obs_rgb.copy(), obs_depth.copy() left_pose_list = mapper_scene2points[scene_name] right_pose_list = [] #for p_idx, p in enumerate(left_pose_list): for p_idx in range(0, 1): p = left_pose_list[p_idx] list_whole = [] x0, y0, theta0 = p left_pose = [x0, y0, theta0] point_file_addr = '{}/point_{}'.format(scene_file_addr, p_idx) create_folder(point_file_addr) current_pose = left_pose left_rgb, left_depth = get_obs(current_pose) cv2.imwrite('{}/left_img.png'.format(point_file_addr), left_rgb[:, :, ::-1]) np.save('{}/left_img_depth.npy'.format(point_file_addr), left_depth) ## add left_img to list_whole current_dict = {} current_dict['img_name'] = 'left_img' current_dict['pose'] = left_pose list_whole.append(current_dict) for i in range(len(theta_list)): if i == 0 or i == 6: len_dist_list = 2 elif i == 1 or i == 5: len_dist_list = 3 elif i == 2 or i == 4: len_dist_list = 10 #4 elif i == 3: len_dist_list = 10 #6 print('len_dist_list = {}'.format(len_dist_list)) for j in range(len_dist_list): location_theta = plus_theta_fn(theta0, theta_list[i]) location_dist = dist_list[j] x1 = x0 + location_dist * math.cos(location_theta) y1 = y0 + location_dist * math.sin(location_theta) left_pixel = path_finder.point_to_pixel(left_pose) right_pixel = path_finder.point_to_pixel((x1, y1)) # check the line flag = rrt.line_check(left_pixel, right_pixel, free) if not flag: print('j = {}, obstacle'.format(j)) else: for diff_theta_idx in range(len(diff_theta_list)): diff_theta = diff_theta_list[diff_theta_idx] theta1 = plus_theta_fn(theta0, diff_theta) right_pose = [x1, y1, theta1] current_pose = right_pose right_rgb, right_depth = get_obs(current_pose) ## check if there is common space between left img and right img kp1, kp2 = sample_gt_dense_correspondences( left_depth, right_depth, left_pose, right_pose, gap=32, focal_length=128, resolution=256, start_pixel=31) if kp1.shape[1] > 2: cv2.imwrite( '{}/right_img_dist_{}_theta_{}_heading_{}.png'. format(point_file_addr, mapper_dist[j], mapper_theta[i], mapper_theta[diff_theta_idx]), right_rgb[:, :, ::-1]) np.save( '{}/right_img_dist_{}_theta_{}_heading_{}_depth.npy' .format(point_file_addr, mapper_dist[j], mapper_theta[i], mapper_theta[diff_theta_idx]), right_depth) right_pose_list.append(right_pose) ## add right_img to list_whole current_dict = {} current_dict[ 'img_name'] = 'right_img_dist_{}_theta_{}_heading_{}'.format( mapper_dist[j], mapper_theta[i], mapper_theta[diff_theta_idx]) current_dict['pose'] = right_pose list_whole.append(current_dict) else: print('No common space') ## save list_whole np.save('{}/point_{}_poses.npy'.format(scene_file_addr, p_idx), list_whole) # plot the pose graph pose_file_addr = '{}'.format(scene_file_addr) img_name = '{}_sampled_poses.jpg'.format(scene_name) print('img_name = {}'.format(img_name)) ## plot the poses free = cv2.imread( '/home/reza/Datasets/GibsonEnv/gibson/assets/dataset/{}_for_rrt/free.png' .format(scene_name), 1) rows, cols, _ = free.shape plt.imshow(free) for m in range(len(left_pose_list)): pose = left_pose_list[m] x, y = path_finder.point_to_pixel((pose[0], pose[1])) theta = pose[2] plt.arrow(x, y, cos(theta), sin(theta), color='r', \ overhang=1, head_width=0.1, head_length=0.15, width=0.001) for m in range(len(right_pose_list)): pose = right_pose_list[m] x, y = path_finder.point_to_pixel((pose[0], pose[1])) theta = pose[2] plt.arrow(x, y, cos(theta), sin(theta), color='b', \ overhang=1, head_width=0.1, head_length=0.15, width=0.001) plt.axis([0, cols, 0, rows]) plt.xticks([]) plt.yticks([]) plt.savefig('{}/{}'.format(pose_file_addr, img_name), bbox_inches='tight', dpi=(400)) plt.close()
def draw_neural_net(ax, left, right, bottom, top, layer_sizes, coefs_, intercepts_, line_width=0.5): ''' Draw a neural network cartoon using matplotilb. :usage: >>> fig = plt.figure(figsize=(12, 12)) >>> draw_neural_net(fig.gca(), .1, .9, .1, .9, [4, 7, 2]) :parameters: - ax : matplotlib.axes.AxesSubplot The axes on which to plot the cartoon (get e.g. by plt.gca()) - left : float The center of the leftmost node(s) will be placed here - right : float The center of the rightmost node(s) will be placed here - bottom : float The center of the bottommost node(s) will be placed here - top : float The center of the topmost node(s) will be placed here - layer_sizes : list of int List of layer sizes, including input and output dimensionality ''' ax.axis('off') n_layers = len(layer_sizes) v_spacing = (top - bottom) / float(max(layer_sizes)) h_spacing = (right - left) / float(len(layer_sizes) - 1) # Input-Arrows layer_top_0 = v_spacing * (layer_sizes[0] - 1) / 2. + (top + bottom) / 2. for m in range(layer_sizes[0]): plt.arrow(left - 0.18, layer_top_0 - m * v_spacing, 0.12, 0, lw=0.1, head_width=0.01, head_length=0.02) # Nodes for n, layer_size in enumerate(layer_sizes): layer_top = v_spacing * (layer_size - 1) / 2. + (top + bottom) / 2. for m in range(layer_size): circle = plt.Circle( (n * h_spacing + left, layer_top - m * v_spacing), v_spacing / 8., color='w', ec='k', zorder=4) if n == 0: plt.text(left - 0.125, layer_top - m * v_spacing, r'$X_{' + str(m + 1) + '}$', fontsize=15) elif (n_layers == 3) & (n == 1): plt.text(n * h_spacing + left + 0.00, layer_top - m * v_spacing + (v_spacing / 8. + 0.01 * v_spacing), r'$a_{' + str(m + 1) + '}$', fontsize=15) elif n == n_layers - 1: # plt.text(n*h_spacing + left+0.10, layer_top - m*v_spacing, r' $\hat{p}_{'+str(m+1)+'}$=sigmoid($h_{'+str(m+1)+'}$)', fontsize=15) plt.text(n * h_spacing + left + 0.10, layer_top - m * v_spacing, r' $h_{' + str(m + 1) + '}$', fontsize=15) ax.add_artist(circle) # Bias-Nodes for n, layer_size in enumerate(layer_sizes): if n < n_layers - 1: x_bias = (n + 0.5) * h_spacing + left y_bias = top + 0.005 circle = plt.Circle((x_bias, y_bias), v_spacing / 8., color='w', ec='k', zorder=4) plt.text(x_bias - (v_spacing / 8. + 0.10 * v_spacing + 0.01), y_bias, r'$1$', fontsize=15) ax.add_artist(circle) # Edges # Edges between nodes for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): layer_top_a = v_spacing * (layer_size_a - 1) / 2. + (top + bottom) / 2. layer_top_b = v_spacing * (layer_size_b - 1) / 2. + (top + bottom) / 2. for m in range(layer_size_a): for o in range(layer_size_b): line = plt.Line2D( [n * h_spacing + left, (n + 1) * h_spacing + left], [layer_top_a - m * v_spacing, layer_top_b - o * v_spacing], c='k', lw=line_width) ax.add_artist(line) xm = (n * h_spacing + left) xo = ((n + 1) * h_spacing + left) ym = (layer_top_a - m * v_spacing) yo = (layer_top_b - o * v_spacing) rot_mo_rad = np.arctan((yo - ym) / (xo - xm)) rot_mo_deg = rot_mo_rad * 180. / np.pi xm1 = xm + (v_spacing / 8. + 0.05) * np.cos(rot_mo_rad) if n == 0: if yo > ym: ym1 = ym + (v_spacing / 8. + 0.12) * np.sin(rot_mo_rad) else: ym1 = ym + (v_spacing / 8. + 0.05) * np.sin(rot_mo_rad) else: if yo > ym: ym1 = ym + (v_spacing / 8. + 0.12) * np.sin(rot_mo_rad) else: ym1 = ym + (v_spacing / 8. + 0.04) * np.sin(rot_mo_rad) # print(n, m, o, str(coefs_[n][m, o])) plt.text( xm1, ym1,\ str(coefs_[n][m, o]),\ rotation = rot_mo_deg, \ fontsize = 12) # Edges between bias and nodes for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): if n < n_layers - 1: layer_top_a = v_spacing * (layer_size_a - 1) / 2. + (top + bottom) / 2. layer_top_b = v_spacing * (layer_size_b - 1) / 2. + (top + bottom) / 2. x_bias = (n + 0.5) * h_spacing + left y_bias = top + 0.005 for o in range(layer_size_b): line = plt.Line2D([x_bias, (n + 1) * h_spacing + left], [y_bias, layer_top_b - o * v_spacing], c='k', lw=line_width) ax.add_artist(line) xo = ((n + 1) * h_spacing + left) yo = (layer_top_b - o * v_spacing) rot_bo_rad = np.arctan((yo - y_bias) / (xo - x_bias)) rot_bo_deg = rot_bo_rad * 180. / np.pi xo2 = xo - (v_spacing / 8. + 0.01) * np.cos(rot_bo_rad) yo2 = yo - (v_spacing / 8. + 0.01) * np.sin(rot_bo_rad) xo1 = xo2 - 0.05 * np.cos(rot_bo_rad) yo1 = yo2 - 0.05 * np.sin(rot_bo_rad) plt.text( xo1, yo1,\ str(intercepts_[n][o]),\ rotation = rot_bo_deg, \ fontsize = 12) # Output-Arrows layer_top_0 = v_spacing * (layer_sizes[-1] - 1) / 2. + (top + bottom) / 2. for m in range(layer_sizes[-1]): plt.arrow(right + 0.015, layer_top_0 - m * v_spacing, 0.16 * h_spacing, 0, lw=1, head_width=0.01, head_length=0.02)
def plot_workspace_data(): plot = True safe_plot = True print_aep_median = False files = None if sys.argv[1] == "-dir": files = os.listdir(sys.argv[2]) files.sort(key=lambda x: os.path.getmtime(sys.argv[2] + "/" + x), reverse=False) print(files) elif len(sys.argv) == 2: files = [sys.argv[1]] else: print( "wrong parameters provide data-filename or -dir directory with files" ) exit() average_step_length_overall = [0, 0, 0, 0, 0, 0] average_step_length_overall_counter = [0, 0, 0, 0, 0, 0] leg_names = ['lf', 'lm', 'lr', 'rr', 'rm', 'rf'] leg_step_length = [[], [], [], [], [], []] run = 0 for file in files: if plot: fig, axs = plt.subplots() plt.xlim(-0.35, 0.3) plt.ylim(-0.4, 0.4) # img = mpimg.imread('/home/jsimmering/plots_masterthesis/images/forPlots/widowX-body.png') img = mpimg.imread( '/home/jsimmering/plots_masterthesis/images/forPlots/body.png') axs.imshow(img, alpha=1.0, aspect='equal', extent=(-0.1378, 0.1378, -0.1164, 0.1164)) legs = [[[]], [[]], [[]], [[]], [[]], [[]]] steps = [0, 0, 0, 0, 0, 0] last_state_swing = [False, False, False, False, False, False] first_line = True file_name = None if len(sys.argv) > 2: file_name = sys.argv[2] + "/" + str(file) else: file_name = str(file) for line in open(str(file_name), 'r'): if first_line: first_line = False pass else: # Clear old plot # plt.clf() line = line.rstrip("\n") values = [float(s) for s in line.split(";")] for i in range(1, 19, 3): if values[i] != 0.0 and values[i + 1] != 0.0: # print("i = {}, (i-1)//3 = {}, steps[{}] = {}, leg[{}] len = {}".format(i, (i-1)//3, (i-1)//3, steps[(i-1)//3], (i-1)//3, len(legs[(i - 1) // 3]))) legs[(i - 1) // 3][steps[(i - 1) // 3]].append( [values[i], values[i + 1]]) last_state_swing[(i - 1) // 3] = False else: if not last_state_swing[(i - 1) // 3]: steps[(i - 1) // 3] += 1 legs[(i - 1) // 3].append([]) last_state_swing[(i - 1) // 3] = True if plot: lf_shoulder = np.matrix([0.1248, 0.06164]).T axs.plot(lf_shoulder.T[:, 0], lf_shoulder.T[:, 1], 'x', color='gray') lm_shoulder = np.matrix([0, 0.1034]).T axs.plot(lm_shoulder.T[:, 0], lm_shoulder.T[:, 1], 'x', color='gray') lr_shoulder = np.matrix([-0.1248, 0.06164]).T axs.plot(lr_shoulder.T[:, 0], lr_shoulder.T[:, 1], 'x', color='gray') rf_shoulder = np.matrix([0.1248, -0.06164]).T axs.plot(rf_shoulder.T[:, 0], rf_shoulder.T[:, 1], 'x', color='gray') rm_shoulder = np.matrix([0, -0.1034]).T axs.plot(rm_shoulder.T[:, 0], rm_shoulder.T[:, 1], 'x', color='gray') rr_shoulder = np.matrix([-0.1248, -0.06164]).T axs.plot(rr_shoulder.T[:, 0], rr_shoulder.T[:, 1], 'x', color='gray') # leg value mapping: ([0, 1, 2, 3, 4, 5], ['lf', 'lm', 'lr', 'rr', 'rm', 'rf']) counter = 0 for leg in legs: #print("leg = " + str(leg_names[legs.index(leg)])) step_length = [] first_step = True for stance in leg: X = [point[0] for point in stance] Y = [point[1] for point in stance] if stance and not first_step: # print("stance = " + str(stance)) # print("beginning = stance[0] = " + str(stance[0])) # print("end = stance[len(stance) - 1] = " + str(stance[len(stance) - 1])) # step_length.append(np.linalg.norm(np.array(stance[len(stance) - 1]) - np.array(stance[0]))) length = 0 start_pos_x = None start_pos_y = None for i in range(1, len(stance)): length += np.linalg.norm( np.array(stance[i]) - np.array(stance[i - 1])) # step_length.append(np.linalg.norm(np.array(stance[len(stance) - 1]) - np.array(stance[0]))) step_length.append(length) #print("step length = " + str(length)) if first_step: first_step = False if plot: axs.plot(X, Y) if [] in leg: leg.remove([]) if print_aep_median: #print("{} leg".format(leg_names[counter])) aeps = [stance[0] for stance in leg] # aeps.sort(key=operator.itemgetter(0, 1)) # print("aeps = " + str(aeps)) # print("aeps length = " + str(len(aeps))) # print("aep lower middle value {} = {}".format(len(aeps)//2, aeps[len(aeps)//2])) # print("aep upper middle value {} = {}".format(len(aeps) // 2 + 1, aeps[len(aeps) // 2 + 1])) print("aep length = {}; / 2 = {}".format( len(aeps), len(aeps) / 2)) if len(aeps) % 2 == 0: aeps.sort(key=operator.itemgetter(0)) print("aep x lower middle value {} = {}".format( len(aeps) // 2, aeps[len(aeps) // 2])) aeps.sort(key=operator.itemgetter(1)) print("aep y lower middle value {} = {}".format( len(aeps) // 2, aeps[len(aeps) // 2])) else: aeps.sort(key=operator.itemgetter(0)) print("aep x lower middle value {} = {}".format( len(aeps) // 2, aeps[len(aeps) // 2])) print("aep x upper middle value {} = {}".format( len(aeps) // 2 + 1, aeps[len(aeps) // 2 + 1])) aeps.sort(key=operator.itemgetter(1)) print("aep y lower middle value {} = {}".format( len(aeps) // 2, aeps[len(aeps) // 2])) print("aep y upper middle value {} = {}".format( len(aeps) // 2 + 1, aeps[len(aeps) // 2 + 1])) if len(step_length) > 0: average_step_length = np.sum(step_length) / len(step_length) if average_step_length: #print("no average_step_length") leg_step_length[counter].append(average_step_length) average_step_length_overall[counter] += average_step_length average_step_length_overall_counter[counter] += 1 else: leg_step_length[counter].append(float('nan')) counter += 1 if plot: # A = [point[0] for point in polygon_list[4]] # A.append(polygon_list[4][0][0]) # A2 = [point[1] for point in polygon_list[4]] # A2.append(polygon_list[4][0][1]) # axs.plot(A, A2) # plt.xlim(-0.3, 0.3) # plt.ylim(-0.4, 0.4) # plt.draw() # plt.pause(0.0001) # axs.axvline(x=0.25, color='b', lw=1) # axs.axvline(x=0.05, color='b', lw=1) # axs.axvline(x=-0.17, color='b', lw=1) axs.plot(0.25, 0.24, 'x', color='b', markersize=16) axs.plot(0.05, (0.24 + 0.04176), 'x', color='b', markersize=16) axs.plot((-0.17), 0.24, 'x', color='b', markersize=16) axs.plot(0.25, -0.24, 'x', color='b', markersize=16) axs.plot(0.05, -(0.24 + 0.04176), 'x', color='b', markersize=16) axs.plot(-0.17, -0.24, 'x', color='b', markersize=16) # circle = plt.Circle((0.25, 0.24), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.05, 0.24 + 0.04176), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((-0.17, 0.24), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.25, -0.24), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.05, -(0.24 + 0.04176)), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((-0.17, -0.24), 0.08, color='g', fill=False) # axs.add_patch(circle) # WIDOWX # axs.plot(0.27, 0.18, 'x', color='b', markersize=16) # axs.plot(0.055, (0.18 + 0.035), 'x', color='b', markersize=16) # axs.plot((-0.17), 0.18, 'x', color='b', markersize=16) # axs.plot(0.27, -0.18, 'x', color='b', markersize=16) # axs.plot(0.055, -(0.18 + 0.035), 'x', color='b', markersize=16) # axs.plot(-0.17, -0.18, 'x', color='b', markersize=16) # circle = plt.Circle((0.27, 0.18), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.055, 0.18 + 0.035), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((-0.17, 0.18), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.27, -0.18), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((0.055, -(0.18 + 0.035)), 0.08, color='g', fill=False) # axs.add_patch(circle) # circle = plt.Circle((-0.17, -0.18), 0.08, color='g', fill=False) # axs.add_patch(circle) # axs.axvline(x=0.25 - 0.08, ymin=0, ymax=0.5, color='g', lw=1) # axs.axvline(x=0.05 - 0.08, ymin=0, ymax=0.5, color='g', lw=1) # axs.axvline(x=-0.17 - 0.08, ymin=0, ymax=0.5, color='g', lw=1) # walk direction split = re.findall(r"[^/_,]+", sys.argv[2], re.ASCII) print(split) # velocity = float(split[-1][:-1]) # counter_damping_fact = (-141.5 * velocity) + 35.5 # stance_speed = (velocity * counter_damping_fact)/35 stance_speed = 0.045 # print("stance speed = " + str(stance_speed)) direction = 0.0 for s in split: if 'dir' in s: direction = float(s.replace('dir', '')) # WidowX # if direction == 0.0: # for s in split: # if 'rad' in s and 'radii' != s: # direction = float(s.replace('rad', '')) print("direction = " + str(direction)) # arrow = plt.arrow(0.111, 0.0, 0.046, 0.0) # axs.add_patch(arrow) # plot_pull_vector([0.111, 0.0], [stance_speed * math.cos(i), stance_speed * math.sin(i)], axs, colors[directions.index(i)]) arrow = plt.arrow(0.111, 0.0, stance_speed * math.cos(direction), stance_speed * math.sin(direction), color='r', head_width=0.01, overhang=0.25) # print("arrow length = " + str(math.sqrt(pow(stance_speed * math.cos(direction), 2) + pow(stance_speed * math.sin(direction), 2)))) axs.add_patch(arrow) stance_diff = -pow(0.28 * (direction - 0.9), 2) + 0.02 print("stance diff = " + str(stance_diff)) if stance_diff < 0: stance_diff = 0 print("stance diff = " + str(stance_diff)) # axs.axvline(x=(0.25 - 0.08) + stance_diff, ymin=0.5, ymax=1, color='g', lw=1) # axs.axvline(x=(0.05 - 0.08) + stance_diff, ymin=0.5, ymax=1, color='g', lw=1) # axs.axvline(x=(-0.17 - 0.08) + stance_diff, ymin=0.5, ymax=1, color='g', lw=1) circle = plt.Circle((0.25, 0.24), 0.08 - stance_diff, color='g', fill=False) axs.add_patch(circle) circle = plt.Circle((0.05, 0.24 + 0.04176), 0.08 - stance_diff, color='g', fill=False) axs.add_patch(circle) circle = plt.Circle((-0.17, 0.24), 0.08 - stance_diff, color='g', fill=False) axs.add_patch(circle) circle = plt.Circle((0.25, -0.24), 0.08, color='g', fill=False) axs.add_patch(circle) circle = plt.Circle((0.05, -(0.24 + 0.04176)), 0.08, color='g', fill=False) axs.add_patch(circle) circle = plt.Circle((-0.17, -0.24), 0.08, color='g', fill=False) axs.add_patch(circle) plt.tick_params(labelsize=35) plt.grid() plt.axis('scaled') # plt.gca().set_aspect('equal', adjustable='box') if safe_plot: plt.subplots_adjust(top=2, bottom=0, right=2, left=0, hspace=1, wspace=1) plt.margins(1, 1) # split = [i.split("_") for i in files] split = re.findall(r"[^/_,]+", file_name, re.ASCII) # print("split = " + str(split)) name = "_".join(split[(split.index("stability") + 4):]) # print("name = " + name) print( "single file: " + "/home/jsimmering/plots_masterthesis/workspace/workspace_" + name + ".svg") plt.savefig( "/home/jsimmering/plots_masterthesis/workspace/workspace_" + name + ".svg", bbox_inches='tight', pad_inches=0, format='svg', transparent=True) # sc.Figure("13.9cm", "15.75cm", # # plt.rcParams["figure.figsize"][0], plt.rcParams["figure.figsize"][1], # sc.Panel(sc.SVG("/home/jsimmering/plots_masterthesis/body.svg").scale(0.03175).move(4.35, 5.1)), # sc.Panel(sc.SVG("/home/jsimmering/plots_masterthesis/workspace/workspace_" + name + ".svg").scale(0.022)) # ).save("/home/jsimmering/plots_masterthesis/workspace/robot_workspace_" + name + ".svg") # SVG("/home/jsimmering/plots_masterthesis/workspace/robot_workspace_" + name + ".svg") else: plt.show() print("") run += 1 # print("length collected = " + str(leg_step_length)) sqrt_errors = [] #print("leg_step_length = " + str(leg_step_length)) print("average_step_length_overall = " + str([ average_step_length_overall[i] / average_step_length_overall_counter[i] for i in range(0, len(average_step_length_overall)) ])) for i in range(0, len(files)): # for each run sqrt_error = 0 error_counter = 0 for j in range(0, 6): # for each leg #print("sqrt_error += ({} - {})^2 = {}".format(leg_step_length[j][i], average_step_length_overall[j]/average_step_length_overall_counter[j], pow(leg_step_length[j][i] - average_step_length_overall[j]/average_step_length_overall_counter[j], 2))) if average_step_length_overall_counter[j] != 0: error = pow( leg_step_length[j][i] - average_step_length_overall[j] / average_step_length_overall_counter[j], 2) if not math.isnan(error): sqrt_error += error error_counter += 1 #print("sqrt_errors.append {}/{} = {}".format(sqrt_error, error_counter, sqrt_error / error_counter)) sqrt_errors.append(sqrt_error / error_counter) min_idx = sqrt_errors.index(min(sqrt_errors)) print("errors = " + str(sqrt_errors) + " idx of min (starting at idx 1) = " + str(min_idx + 1)) print("\n\n") print("**workspace:** run " + str(min_idx + 1)) print("") file_name = None if len(sys.argv) > 2: file_name = sys.argv[2] + "/" + str(files[min_idx]) else: file_name = str(files[min_idx]) split = re.findall(r"[^/_,]+", file_name, re.ASCII) name = "_".join(split[(split.index("stability") + 4):]) print("workspace_" + name + ".png") print("**average step length over all runs:**") #print("average_step_length_overall = " + str(average_step_length_overall)) for i in [0, 5, 1, 4, 2, 3]: # print("{} leg = {}".format(leg_names[i], round(average_step_length_overall[i] / len(files), 5))) try: print(str( round( average_step_length_overall[i] / average_step_length_overall_counter[i], 3)) + " & ", end="") except ZeroDivisionError: print(" nan & ", end="") print("") print("") for i in [0, 5, 1, 4, 2, 3]: # print("{} leg = {}".format(leg_names[i], round(average_step_length_overall[i] / len(files), 5))) try: print(str(average_step_length_overall[i] / average_step_length_overall_counter[i]) + " ", end="") except ZeroDivisionError: print(" nan ", end="") print("") print("") print([ round( average_step_length_overall[i] / average_step_length_overall_counter[i], 3) for i in [0, 5, 1, 4, 2, 3] ]) print("") print("")
def plot_contours(Xdata, ydata, model, loss_fn, traces=None): Xvar = Variable(torch.from_numpy(Xdata)).float() yvar = Variable(torch.from_numpy(ydata)).float() x = np.arange(-8.0, 6.1, 0.1) y = np.arange(-2.0, 8.1, 0.1) # x = np.arange(-2.5, 5.6, 0.1) # y = np.arange(-1.0, 3.6, 0.1) X, Y = np.meshgrid(x, y) Z = np.empty_like(X) for i in range(X.shape[0]): for j in range(X.shape[1]): model.fc.weight.data = torch.FloatTensor([[X[i, j], Y[i, j]]]) output = model(Xvar) loss = loss_fn(output, yvar) Z[i, j] = float(loss.data) # fig = plt.figure(figsize=(4, 3)) fig, ax = plt.subplots(figsize=(4, 3)) CS = ax.contour(X, Y, Z, levels=[0.1, 0.25, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0, 10.0]) ax.clabel(CS, inline=1, fontsize=10, fmt='%1.2f') cind = 0 colors = ['black', 'red', 'blue', 'green', 'gray'] label_map = dict(sgd="SGD", ngd="NGD", natural_adam="FANG-Adam", natural_amsgrad="FANG-Ams", natural_adagrad="FANG-Ada") if traces is not None: for k, v in traces.items(): lines = [] tr = v for i in range(len(tr) - 1): lines.append([tr[i], tr[i + 1]]) # ax.scatter(*zip(*tr), marker='o', c=colors[cind], s=4, label=label_map[k]) # This is not visible but used to get legend lc = mc.LineCollection(lines, color=colors[cind], linewidths=1.0, label=label_map[k], visible=False) ax.add_collection(lc) for line in lines: arrow = plt.arrow(line[0][0], line[0][1], line[1][0] - line[0][0], line[1][1] - line[0][1], color=colors[cind], length_includes_head=True, head_width=0.1, head_length=0.1, zorder=1000) cind += 1 plt.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off labelbottom=False) # labels along the bottom edge are off plt.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected left=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off labelleft=False) # labels along the bottom edge are off plt.legend() plt.tight_layout() plt.savefig('contour_large.pdf')
def sgr_xyz_plots(stripes, params): """ Plots stream positions & directions in galactic XYZ""" positions = sc.zeros((len(stripes), 3)) vectors = sc.zeros((len(stripes), 3)) for i, stripe in enumerate(stripes): positions[i, 0], positions[i, 1], positions[i, 2] = coor.GC2xyz( eval(params[i][4]), 0.0, eval(params[i][5]), stripe) if stripe == 9 or stripe == 22 or stripe == 82: theta, phi = (ma.pi - eval(params[i][6])), (eval(params[i][7]) + ma.pi) else: theta, phi = eval(params[i][6]), eval(params[i][7]) theta, phi = coor.angle_bounds3(theta * deg, phi * deg, phi_max=180.0) theta, phi = theta * rad, phi * rad print stripe, theta, phi vectors[i, 0] = ma.sin(theta) * ma.cos(phi) vectors[i, 1] = ma.sin(theta) * ma.sin(phi) vectors[i, 2] = ma.cos(theta) off = 1.0 """ Plot xy """ plt.figure(1) #ax = plt.subplot(111) plt.scatter(GC[0], GC[1], s=40, edgecolor="k", marker="o", facecolor="black") plt.text(GC[0] + off, GC[1] + off, "GC", fontsize=10) plt.scatter(sun[0], sun[1], s=20, edgecolor="k", marker=(8, 2, 0), facecolor="white") plt.text(sun[0] + off, sun[1] + off, "Sun", fontsize=10) plt.scatter(Sgr[0], Sgr[1], s=20, edgecolor="k", marker="o", facecolor="black") plt.text(Sgr[0] + off, Sgr[1] + off, "Sgr Core", fontsize=10) t = sc.arange(0.0, 2.0 * ma.pi, 0.01) plt.plot(30.0 * sc.cos(t), 30.0 * sc.sin(t), "k:") offset_x = [ 0.0, 0.0, 0.0, -1.0, -2.0, -1.0, -1.0, 0.0, 0.0, 0.0, -1.0, -2.0, -3.2, -3.0, 0.5, 0.0, 0.0, -1.0 ] offset_y = [ 0.0, 0.0, -1.0, -1.9, 0.2, 0.5, 0.5, -1.0, -2.0, -3.0, -3.0, -2.9, -2.5, 0.5, 0.5, -2.0, -2.0, -2.25 ] for i in range(len(stripes)): #plt.annotate(str(stripes[i]), xy=(positions[i,0], positions[i,1]), # xytext=( (positions[i,0]+(vectors[i,0]*100.0)), (positions[i,1]+(vectors[i,1]*100.0)) ), # arrowprops=dict(facecolor='black', arrowstyle="->") ) if stripes[i] < 75: color = 'white' else: color = 'black' plt.arrow(positions[i, 0], positions[i, 1], vectors[i, 0] * 10.0, vectors[i, 1] * 10.0, width=0.20, head_width=1.5, facecolor=color) if stripes[i] < 20 or stripes[i] > 19: plt.text(positions[i, 0] + offset_x[i], positions[i, 1] + offset_y[i], r"$" + str(stripes[i]) + r"$", fontsize=10) plt.xlabel(r"$X_{GC}$ (kpc)") plt.ylabel(r"$Y_{GC}$ (kpc)") plt.axis('equal') plt.ylim(-30, 30) plt.xlim(-30, 30) locs, labels = plt.xticks() for i in range(len(labels)): labels[i] = r"$" + str(locs[i]) + r"$" plt.xticks(locs, labels, fontsize=12) locs, labels = plt.yticks() for i in range(len(labels)): labels[i] = r"$" + str(locs[i]) + r"$" plt.yticks(locs, labels, fontsize=12) """ Plot xz """ plt.figure(2) #ax = plt.subplot(111) plt.scatter(GC[0], GC[2], s=40, edgecolor="k", marker="o", facecolor="black") plt.text(GC[0] + off, GC[2] + off, r"GC", fontsize=10) plt.scatter(sun[0], sun[2], s=20, edgecolor="k", marker=(8, 2, 0), facecolor="white") plt.text(sun[0] + off, sun[2] + off, "Sun", fontsize=10) plt.scatter(Sgr[0], Sgr[2], s=20, edgecolor="k", marker="o", facecolor="black") plt.text(Sgr[0] + off, Sgr[2] + off, "Sgr Core", fontsize=10) plt.plot([-30.0, 30.0], [0.0, 0.0], "k:") offset_x = [ 0.2, 0.0, 0.0, -0.2, 0.0, 0.0, 0.0, -0.5, 1.0, 1.0, 0.5, 0.75, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0 ] offset_z = [ 0.0, 0.0, 0.0, -2.5, 0.0, 0.0, -2.0, 0.5, -1.0, -1.0, 0.25, -1.0, -0.5, 0.0, -0.5, 0.0, 0.5, 0.5 ] for i in range(len(stripes)): #plt.annotate(str(stripes[i]), xytext=(positions[i,0], positions[i,2]), # xy=( (positions[i,0]+(vectors[i,0]*10.0)), (positions[i,2]+(vectors[i,2]*10.0)) ), # arrowprops=dict(facecolor='black', arrowstyle="->") ) if stripes[i] < 75: color = 'white' else: color = 'black' plt.arrow(positions[i, 0], positions[i, 2], vectors[i, 0] * 10.0, vectors[i, 2] * 10.0, width=0.25, head_width=2.0, facecolor=color) if stripes[i] < 20 or stripes[i] > 19: plt.text(positions[i, 0] + offset_x[i], positions[i, 2] + offset_z[i], r"$" + str(stripes[i]) + r"$", fontsize=10) plt.xlabel(r"$X_{GC}$ (kpc)") plt.ylabel(r"$Z_{GC}$ (kpc)") plt.axis('equal') plt.xlim(-45, 45) plt.ylim(-40, 50) locs, labels = plt.xticks() for i in range(len(labels)): labels[i] = r"$" + str(locs[i]) + r"$" plt.xticks(locs, labels, fontsize=12) locs, labels = sc.arange(-40.0, 50.0, 20.0), [] for i in range(len(locs)): labels.append(r"$" + str(locs[i]) + r"$") plt.yticks(locs, labels, fontsize=12) # done plt.show()
def twoBody(): # state for each body is [x, y] for position, [u, v] for speed # total state is [x1,y1,u1,v1,x2,y2,u2,v2] m1 = 1; m2 = 1; G = 1 x0 = np.array([0., 0., 0., -1., 1, 0., 0.2, 0.2]) # returns gravitational force from first object on second according # Newton's law of gravitation def gForce(x): r = x[0:2] - x[4:6] return (G * m1 * m2 / ((r[0]**2 + r[1]**2) ** (1.5))) * r def dx(t, x): r = gForce(x) return np.array([ x[2], x[3], -r[0]/m1, -r[1]/m1, x[6], x[7], r[0]/m2, r[1]/m2, ]) ode = ODE(0, x0) ode.dx = dx dt = 0.001 iters = 6000 method = "rk4" res = [deepcopy(ode)] for _ in range(iters): ode.evolve(dt, method=method) res.append(deepcopy(ode)) x1s = [o.x[0] for o in res] y1s = [o.x[1] for o in res] x2s = [o.x[4] for o in res] y2s = [o.x[5] for o in res] ts = [o.t for o in res] plt.plot(x1s, y1s, '.-', markersize=0.7, linewidth=0.4, color='orange') plt.plot(x2s, y2s, '.-', markersize=0.7, linewidth=0.2, color='blue') X = res[0].x plt.arrow(X[0], X[1], X[2], X[3], color="orange", head_width=0.05) plt.arrow(X[4], X[5], X[6], X[7], color="blue", head_width=0.05) plt.text(X[0], X[1], r"$t=0$" + "\n" "$position=({},{})$".format(X[0], X[1])+ "\n" + "$velocity=({},{})$".format(X[2], X[3]), fontsize=12, color = "orange", horizontalalignment='right', verticalalignment='top') plt.text(X[4], X[6], r"$t=0$" + "\n" "$position=({},{})$".format(X[4], X[5]) + "\n" + "$velocity=({},{})$".format(X[6], X[7]), fontsize=12, color = "blue", horizontalalignment='left', verticalalignment='bottom') plt.xlim(-3, 3) plt.ylim(-3, 3) legend1 = "Mass: {}, method: {}".format(m1, method) legend2 = "Mass: {}, ".format(m2) + r"$\Delta t=$" + "${}$".format(dt) plt.legend([legend1, legend2]) plt.xlabel("$x$") plt.ylabel("$y$") plt.title(r"Two Body Motion for $t \in " + "[{}, {}]$".format(res[0].t, iters*dt)) #plt.savefig("twoBody5.svg", format='svg') plt.show()
y_random_position = [0, 0, L1 * s1, L1 * s1 + L2 * s12, L1 * s1 + L2 * s12 + L3 * s123] x_random_position = [0, L0, L0 + L1 * c1, L0 + L1 * c1 + L2 * c12, L0 + L1 * c1 + L2 * c12 + L3 * c123] plt.plot(y_random_position, x_random_position, marker='o') ''' #plt.grid() #y_current = [L1 * s1 + L2 * s12 + L3 * s123, L1 * s1 + L2 * s12 + 170 * s123] #x_current = [L0 + L1 * c1 + L2 * c12 + L3 * c123, L0 + L1 * c1 + L2 * c12 + 170 * c123] #plt.plot(y_current, x_current) plt.arrow(L1 * s1 + L2 * s12 + L3 * s123, L0 + L1 * c1 + L2 * c12 + L3 * c123, -(L1 * s1 + L2 * s12 + L3 * s123) + (L1 * s1 + L2 * s12 + 200 * s123), -(L0 + L1 * c1 + L2 * c12 + L3 * c123) + (L0 + L1 * c1 + L2 * c12 + 200 * c123), width = 5, head_length = 20) print(Q1) print(Q2) plot_man_ik(Q1, Q2) plt.xlim(-453.75, 453.75) plt.ylim(0, 497.11) plt.show()
def plot_with_CFD_score(df, out_folder, guide): # Remove targets with mm+bul<=1 since they are probably on-target introduced by variants df = df.loc[df["Mismatches+bulges_(highest_CFD)"] > 1] # sort values to have highest scored target on top df.sort_values('CFD_score_(highest_CFD)', ascending=False, inplace=True) # keep top1000 targets df = df.head(1000) # Make index column that numbers the OTs starting from 1 df.reset_index(inplace=True) index_count = 1 for index in df.index: df.loc[index, 'index'] = index_count index_count += 1 # If prim_AF = 'n', then it's a ref-nominated site, so we enter a fake numerical AF # This will cause a warning of invalid sqrt later on, but that's fine to ignore df["Variant_MAF_(highest_CFD)"] = df["Variant_MAF_(highest_CFD)"].fillna( -1) # If multiple AFs (haplotype with multiple SNPs), take min AF # Approximation until we have haplotype frequencies df["AF"] = df["Variant_MAF_(highest_CFD)"].astype(str).str.split(',') df["AF"] = df["AF"].apply(lambda x: min(x)) df["AF"] = pd.to_numeric(df["AF"]) # Adjustments for plotting purposes # so haplotypes that got rounded down to AF = 0 (min AF = 0.01) still appear in the plot df["plot_AF"] = df["AF"] + 0.001 df["plot_AF"] *= 1000 # make points larger df["plot_AF"] = np.sqrt(df["plot_AF"]) # so size increase is linear # Calculate ref_AF as (1 – alt_AF) # Not precisely correct because there can be other non-ref haplotypes, but approximation should be accurate in most cases df["ref_AF"] = 1 - df["AF"] df["ref_AF"] *= 1000 # make points larger df["ref_AF"] = np.sqrt(df["ref_AF"]) # so size increase is linear # Transparent colors transparent_red = mcolors.colorConverter.to_rgba("red", alpha=0.5) transparent_blue = mcolors.colorConverter.to_rgba("blue", alpha=0.5) transparent_gray = mcolors.colorConverter.to_rgba("gray", alpha=0.5) """ # Linear, annotated, top 100 (for supplement) # """ # # Size legend s1 = mlines.Line2D([], [], marker='o', label='1', linestyle='None', markersize=math.sqrt(math.sqrt((1 + 0.001) * 1000)), color='black') s01 = mlines.Line2D([], [], marker='o', label='0.1', linestyle='None', markersize=math.sqrt(math.sqrt((0.1 + 0.001) * 1000)), color='black') s001 = mlines.Line2D([], [], marker='o', label='0.01', linestyle='None', markersize=math.sqrt(math.sqrt( (0.01 + 0.001) * 1000)), color='black') """ Log, ref/alt, top 1000: for main text """ # matplotlib plot settings plt.rcParams["figure.dpi"] = 600 plt.rcParams["figure.figsize"] = 7.5, 2.25 plt.rcParams.update({'font.size': 7}) plt.rcParams['pdf.fonttype'] = 42 plt.rcParams['ps.fonttype'] = 42 # Plot data CFD SCORE ax = df.plot.scatter(x="index", y="CFD_score_REF_(highest_CFD)", s="ref_AF", c=transparent_red, zorder=1) # ax = df.plot.scatter(x="index", y="highest_CFD_score(ref)", s="ref_AF", c=transparent_red, zorder=1, ax=ax) df.plot.scatter(x="index", y="CFD_score_ALT_(highest_CFD)", s="plot_AF", c=transparent_blue, zorder=2, ax=ax) ax.set_xscale("log") plt.xlabel("Candidate off-target site") plt.ylabel("CFD score") # Boundaries plt.xlim(xmin=0.9, xmax=1000) plt.ylim(ymin=0, ymax=1) # Arrows for x, y, z in zip( df["index"], df["CFD_score_REF_(highest_CFD)"], df["CFD_score_ALT_(highest_CFD)"] - df["CFD_score_REF_(highest_CFD)"]): plt.arrow(x, y + 0.02, 0, z - 0.04, color='gray', head_width=(x * (10**0.005 - 10**(-0.005))), head_length=0.02, length_includes_head=True, zorder=0, alpha=0.5) # +/- to avoid overlap of arrow w/ points, head_width calculated to remain constant despite log scale of x-axis # Size legend plt.gca().add_artist( plt.legend(handles=[s1, s01, s001], title="Allele frequency", ncol=3, loc=9)) # Color legend red = mpatches.Patch(color=transparent_red, label="Reference") blue = mpatches.Patch(color=transparent_blue, label="Alternative") plt.legend(handles=[red, blue]) # Save plt.tight_layout() plt.savefig(out_folder + f"CRISPRme_CFD_top_1000_log_for_main_text_{guide}.png") plt.clf()
def electre_i_v(dataset, V, W, remove_cycles=False, c_hat=0.75, graph=True): kernel = [] dominated = [] concordance = concordance_matrix(dataset, W) discordance = discordance_matrix(dataset, V) dominance = dominance_matrix(concordance, discordance, c_hat=c_hat, d_hat=0.5) if (remove_cycles == True): dominance = johnson_algorithm_cycles(dominance) row_sum = np.sum(dominance, axis=0) kernel = np.where(row_sum == 0)[0].tolist() for j in range(0, dominance.shape[1]): for i in range(0, len(kernel)): if (dominance[kernel[i], j] == 1): if (j not in dominated): dominated.append(j) limit = len(kernel) for j in range(0, dominance.shape[1]): for i in range(0, limit): if (dominance[kernel[i], j] == 0 and np.sum(dominance[:, j], axis=0) > 0): if (j not in dominated and j not in kernel): kernel.append(j) kernel = ['a' + str(alt + 1) for alt in kernel] dominated = ['a' + str(alt + 1) for alt in dominated] if (graph == True): for i in range(0, dominance.shape[0]): radius = 1 node_x = radius * math.cos(math.pi * 2 * i / dominance.shape[0]) node_y = radius * math.sin(math.pi * 2 * i / dominance.shape[0]) if ('a' + str(i + 1) in kernel): plt.text(node_x, node_y, 'a' + str(i + 1), size=12, ha='center', va='center', bbox=dict( boxstyle='round', ec=(0.0, 0.0, 0.0), fc=(0.8, 1.0, 0.8), )) else: plt.text(node_x, node_y, 'a' + str(i + 1), size=12, ha='center', va='center', bbox=dict( boxstyle='round', ec=(0.0, 0.0, 0.0), fc=(1.0, 0.8, 0.8), )) for i in range(0, dominance.shape[0]): for j in range(0, dominance.shape[1]): node_xi = radius * math.cos( math.pi * 2 * i / dominance.shape[0]) node_yi = radius * math.sin( math.pi * 2 * i / dominance.shape[0]) node_xj = radius * math.cos( math.pi * 2 * j / dominance.shape[0]) node_yj = radius * math.sin( math.pi * 2 * j / dominance.shape[0]) if (dominance[i, j] == 1): if ('a' + str(i + 1) in kernel): plt.arrow(node_xi, node_yi, node_xj - node_xi, node_yj - node_yi, head_width=0.01, head_length=0.2, overhang=0.0, color='black', linewidth=0.9, length_includes_head=True) else: plt.arrow(node_xi, node_yi, node_xj - node_xi, node_yj - node_yi, head_width=0.01, head_length=0.2, overhang=0.0, color='red', linewidth=0.9, length_includes_head=True) axes = plt.gca() axes.set_xlim([-radius, radius]) axes.set_ylim([-radius, radius]) plt.axis('off') plt.show() return concordance, discordance, dominance, kernel, dominated
def render(self, mode='human', title=None): color_map = "gist_ncar" if title is None: title = self.env_name r, c = self.agent_location x2, y2 = 0, 0 if self.agent_facing_str == 'NORTH': x2, y2 = 0, -0.01 elif self.agent_facing_str == 'SOUTH': x2, y2 = 0, 0.01 elif self.agent_facing_str == 'WEST': x2, y2 = -0.01, 0 elif self.agent_facing_str == 'EAST': x2, y2 = 0.01, 0 plt.figure(title, figsize=(9, 5)) plt.imshow(self.map, cmap=color_map, vmin=0, vmax=len(self.items_id)) plt.arrow(c, r, x2, y2, head_width=0.7, head_length=0.7, color='white') plt.title('NORTH', fontsize=10) plt.xlabel('SOUTH') plt.ylabel('WEST') plt.text(self.map_width, self.map_width // 2, 'EAST', rotation=90) # plt.text(self.map_size, self.map_size // 2, 'EAST', rotation=90) # plt.colorbar() # plt.grid() info = '\n'.join([ " Info: ", "Env: " + self.env_name, "Steps: " + str(self.step_count), "Agent Facing: " + self.agent_facing_str, "Action: " + self.action_str[self.last_action], "Reward: " + str(self.last_reward), "Done: " + str(self.last_done) ]) props = dict(boxstyle='round', facecolor='w', alpha=0.2) plt.text(-(self.map_width // 2) - 0.5, 2.25, info, fontsize=10, bbox=props) # x, y # plt.text(-(self.map_size // 2) - 0.5, 2.25, info, fontsize=10, bbox=props) # x, y if self.last_done: you_win = "YOU WIN " + self.env_name + "!!!" props = dict(boxstyle='round', facecolor='w', alpha=1) # plt.text(0 - 0.1, (self.map_size // 2), you_win, fontsize=18, bbox=props) plt.text(0 - 0.1, (self.map_width // 2), you_win, fontsize=18, bbox=props) cmap = get_cmap(color_map) legend_elements = [ Line2D([0], [0], marker="^", color='w', label='agent', markerfacecolor='w', markersize=12, markeredgewidth=2, markeredgecolor='k'), Line2D([0], [0], color='w', label="INVENTORY:") ] for item in sorted(self.inventory_items_quantity): rgba = cmap(self.items_id[item] / len(self.items_id)) legend_elements.append( Line2D([0], [0], marker="s", color='w', label=item + ': ' + str(self.inventory_items_quantity[item]), markerfacecolor=rgba, markersize=16)) plt.legend(handles=legend_elements, bbox_to_anchor=(1.55, 1.02)) # x, y plt.tight_layout() plt.pause(0.01) plt.clf()
def plot_with_MMvBUL(df, out_folder, guide): # Remove targets ref with mm+bul<=1 for on-targets and on-targets variant-induced df = df.loc[df["Mismatches+bulges_(fewest_mm+b)"] > 1] # new col to store the scoring value for non-SpCas9 targets df['Mismatches+bulges_REF_(fewest_mm+b)'] = 0 df['Mismatches+bulges_ALT_(fewest_mm+b)'] = 0 # compute analysis to reference_count_analysis df = df.apply(reference_count_analysis, axis=1) # df = df.apply( # lambda row: reference_count_analysis(row), axis=1) # if col is alt calculate score for ref and alt, if ref skip # for index in df.index: # if df.loc[index, 'REF/ALT_origin_(fewest_mm+b)'] == 'alt': # refTarget = str( # df.loc[index, 'Aligned_protospacer+PAM_REF_(fewest_mm+b)']) # countMM = 0 # for nt in refTarget: # if nt.islower(): # countMM += 1 # df.loc[index, 'Mismatches+bulges_REF_(fewest_mm+b)'] = countMM + \ # int(df.loc[index, 'Bulges_(fewest_mm+b)']) # df.loc[index, 'Mismatches+bulges_ALT_(fewest_mm+b)'] = df.loc[index, # 'Mismatches+bulges_(fewest_mm+b)'] # else: # df.loc[index, 'Mismatches+bulges_REF_(fewest_mm+b)'] = df.loc[index, # 'Mismatches+bulges_(fewest_mm+b)'] # df.loc[index, 'Mismatches+bulges_ALT_(fewest_mm+b)'] = df.loc[index, # 'Mismatches+bulges_(fewest_mm+b)'] # sort in order to have highest REF mm+bul on top df.sort_values('Mismatches+bulges_(fewest_mm+b)', ascending=True, inplace=True) # top1000 targets df = df.head(1000) # Make index column that numbers the OTs starting from 1 df.reset_index(inplace=True) index_count = 1 for index in df.index: df.loc[index, 'index'] = index_count index_count += 1 # If prim_AF = 'n', then it's a ref-nominated site, so we enter a fake numerical AF # This will cause a warning of invalid sqrt later on, but that's fine to ignore # df["prim_AF"] = df["prim_AF"].fillna(-1) df["Variant_MAF_(fewest_mm+b)"] = df["Variant_MAF_(fewest_mm+b)"].fillna( -1) # If multiple AFs (haplotype with multiple SNPs), take min AF # Approximation until we have haplotype frequencies df["AF"] = df["Variant_MAF_(fewest_mm+b)"].astype(str).str.split(',') df["AF"] = df["AF"].apply(lambda x: min(x)) df["AF"] = pd.to_numeric(df["AF"]) # Adjustments for plotting purposes # so haplotypes that got rounded down to AF = 0 (min AF = 0.01) still appear in the plot df["plot_AF"] = df["AF"] + 0.001 df["plot_AF"] *= 1000 # make points larger df["plot_AF"] = np.sqrt(df["plot_AF"]) # so size increase is linear # Calculate ref_AF as (1 – alt_AF) # Not precisely correct because there can be other non-ref haplotypes, but approximation should be accurate in most cases df["ref_AF"] = 1 - df["AF"] df["ref_AF"] *= 1000 # make points larger df["ref_AF"] = np.sqrt(df["ref_AF"]) # so size increase is linear # Transparent colors transparent_red = mcolors.colorConverter.to_rgba("red", alpha=0.5) transparent_blue = mcolors.colorConverter.to_rgba("blue", alpha=0.5) transparent_gray = mcolors.colorConverter.to_rgba("gray", alpha=0.5) # # Size legend s1 = mlines.Line2D([], [], marker='o', label='1', linestyle='None', markersize=math.sqrt(math.sqrt((1 + 0.001) * 1000)), color='black') s01 = mlines.Line2D([], [], marker='o', label='0.1', linestyle='None', markersize=math.sqrt(math.sqrt((0.1 + 0.001) * 1000)), color='black') s001 = mlines.Line2D([], [], marker='o', label='0.01', linestyle='None', markersize=math.sqrt(math.sqrt( (0.01 + 0.001) * 1000)), color='black') """ Log, ref/alt, top 1000: for main text """ # matplotlib plot settings plt.rcParams["figure.dpi"] = 600 plt.rcParams["figure.figsize"] = 7.5, 2.25 plt.rcParams.update({'font.size': 7}) plt.rcParams['pdf.fonttype'] = 42 plt.rcParams['ps.fonttype'] = 42 # Plot data ax = df.plot.scatter(x="index", y="Mismatches+bulges_REF_(fewest_mm+b)", s="ref_AF", c=transparent_red, zorder=1) # ax = df.plot.scatter(x="index", y="highest_CFD_score(ref)", s="ref_AF", c=transparent_red, zorder=1, ax=ax) df.plot.scatter(x="index", y="Mismatches+bulges_ALT_(fewest_mm+b)", s="plot_AF", c=transparent_blue, zorder=2, ax=ax) ax.set_xscale("log") # plt.title("Top CRISPRme-identified sites for sgRNA 1617") plt.xlabel("Candidate off-target site") plt.ylabel("Mismatches+Bulges") # Boundaries plt.xlim(xmin=0.9, xmax=1000) # plt.ylim(ymin=0, ymax=1) # Arrows for x, y, z in zip( df["index"], df["Mismatches+bulges_REF_(fewest_mm+b)"], df["Mismatches+bulges_ALT_(fewest_mm+b)"] - df["Mismatches+bulges_REF_(fewest_mm+b)"]): plt.arrow(x, y + 0.02, 0, z - 0.04, color='gray', head_width=(x * (10**0.005 - 10**(-0.005))), head_length=0.02, length_includes_head=True, zorder=0, alpha=0.5) # +/- to avoid overlap of arrow w/ points, head_width calculated to remain constant despite log scale of x-axis # Size legend plt.gca().add_artist( plt.legend(handles=[s1, s01, s001], title="Allele frequency", ncol=3, loc=9)) # Color legend red = mpatches.Patch(color=transparent_red, label="Reference") blue = mpatches.Patch(color=transparent_blue, label="Alternative") plt.legend(handles=[red, blue]) # Save plt.tight_layout() plt.savefig(out_folder + f"CRISPRme_fewest_top_1000_log_for_main_text_{guide}.png") plt.clf()
# Train random forest classifier, calibrate on validation data and evaluate # on test data clf = RandomForestClassifier(n_estimators=25) clf.fit(X_train, y_train) clf_probs = clf.predict_proba(X_test) sig_clf = CalibratedClassifierCV(clf, method="sigmoid", cv="prefit") sig_clf.fit(X_valid, y_valid) sig_clf_probs = sig_clf.predict_proba(X_test) sig_score = log_loss(y_test, sig_clf_probs) # Plot changes in predicted probabilities via arrows plt.figure() colors = ["r", "g", "b"] for i in range(clf_probs.shape[0]): plt.arrow(clf_probs[i, 0], clf_probs[i, 1], sig_clf_probs[i, 0] - clf_probs[i, 0], sig_clf_probs[i, 1] - clf_probs[i, 1], color=colors[y_test[i]], head_width=1e-2) # Plot perfect predictions plt.plot([1.0], [0.0], 'ro', ms=20, label="Class 1") plt.plot([0.0], [1.0], 'go', ms=20, label="Class 2") plt.plot([0.0], [0.0], 'bo', ms=20, label="Class 3") # Plot boundaries of unit simplex plt.plot([0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], 'k', label="Simplex") # Annotate points on the simplex plt.annotate(r'($\frac{1}{3}$, $\frac{1}{3}$, $\frac{1}{3}$)', xy=(1.0/3, 1.0/3), xytext=(1.0/3, .23), xycoords='data', arrowprops=dict(facecolor='black', shrink=0.05), horizontalalignment='center', verticalalignment='center')
plt.xticks([], []) plt.yticks([], []) plt.axis("off") plt.gca().set_aspect("equal") plt.gca().xaxis.set_major_locator(plt.NullLocator()) plt.gca().yaxis.set_major_locator(plt.NullLocator()) # draw arrows hw = 0.020 hl = 0.02 c = axis_color plt.arrow(0, 0, 1.05, 0, head_width=hw, head_length=hl, length_includes_head=True, ec=c, fc=c) plt.arrow(0, 0, -1.05, 0, head_width=hw, head_length=hl, length_includes_head=True, ec=c, fc=c) # draw ticks
ax.plot(X1_ellipse, X2_ellipse_2, 'r') # Plot the points found during the iterations ax.plot(points_x, points_y, 'b') # Plot the point that minimized the function (analitycally found) ax.plot(veps[0, idx], veps[1, idx], 'go') # Save the current figure plt.savefig('../Images/03-pca-analysis-numerical.png') # Create a new figure fig = plt.figure() # Split the figure in 1*1 (nrows*ncols) subaxes and create a new suplot positioned at 1 (plot_number) nrows = 1 ncols = 1 plot_number = 1 ax = fig.add_subplot(nrows, ncols, plot_number) # Set the labels for the axes ax.set_xlabel('$x_1$') ax.set_ylabel('$x_2$') # Plot the samples ax.plot(c1[:, 0], c1[:, 1], 'r.') # Plot the eigenvector related to the maximum eigenvalue plt.arrow(np.mean(c1[:, 0]), np.mean(c1[:, 1]), vaps[idx] * veps[0, idx], vaps[idx] * veps[1, idx], 0.5, linewidth=1, head_width=0.1, color='blue') # Save the current figure plt.savefig('../Images/03-pca-analysis-scatterplot.png')
def render_scene(self): while True: yield self.env.timeout(1) number_agvs = len(self.global_robot_list.items) ax = plt.subplot2grid((1, number_agvs + 3), (0, 0), colspan=3) plt.subplots_adjust(wspace=1.5, hspace=0.4) plt.title("agv Layout") plt.style.use('dark_background') # Plot Graph self.graph.plot(ax) # Plot AGVs for robot in self.global_robot_list.items: color = self.colors[robot.ID - 1] plt.plot(robot.robot_location[0], robot.robot_location[1], color=color, marker='o', ms=10) plt.arrow(robot.robot_location[0], robot.robot_location[1], math.cos(robot.heading_direction), math.sin(robot.heading_direction), width=0.3, color=color) plt.text(robot.robot_location[0] + 0.5, robot.robot_location[1] + 1.5, str("agv" + str(robot.ID))) # Plot path if robot.path: node_pos = self.kb['graph'].nodes[robot.path[0]].pos plt.plot([robot.robot_location[0], node_pos[0]], [robot.robot_location[1], node_pos[1]], color=color, lw=3.5) for i in range(len(robot.path)): node_pos = self.kb['graph'].nodes[robot.path[i]].pos plt.plot(node_pos[0], node_pos[1], color=color, marker='.', ms=15) if i < len(robot.path) - 1: node_pos_ = self.kb['graph'].nodes[robot.path[ i + 1]].pos plt.plot([node_pos[0], node_pos_[0]], [node_pos[1], node_pos_[1]], color=color, lw=3.5) # Plot total path if robot.total_path: for i in range(len(robot.total_path)): node_pos = self.kb['graph'].nodes[ robot.total_path[i]].pos plt.plot(node_pos[0], node_pos[1], color=color, marker='.', ms=15) if i < len(robot.total_path) - 1: node_pos_ = self.kb['graph'].nodes[ robot.total_path[i + 1]].pos plt.plot([node_pos[0], node_pos_[0]], [node_pos[1], node_pos_[1]], color=color, lw=1.5) # Plot assigned tasks for key in self.kb.keys(): if key == 'local_task_list_R' + str(robot.ID): list_ = self.kb[key] for item in list_.items: node_pos = self.kb['graph'].nodes[item.pos_A].pos plt.plot(node_pos[0], node_pos[1], 'bs', ms=7) plt.text(node_pos[0] - 1, node_pos[1] + 1.5, str(item.order_number)) plt.plot([robot.robot_location[0], node_pos[0]], [robot.robot_location[1], node_pos[1]], color=color, lw=0.5) # Plot tasks executing for task in self.tasks_executing.items: node_pos = self.kb['graph'].nodes[task.pos_A].pos plt.plot(node_pos[0], node_pos[1], 'rs', ms=7) plt.text(node_pos[0] - 1, node_pos[1] + 1.5, str(task.order_number)) # Plot tasks in global task list for task in self.global_task_list.items: node_pos = self.kb['graph'].nodes[task.pos_A].pos plt.plot(node_pos[0], node_pos[1], 'gs', ms=7) plt.text(node_pos[0] - 1, node_pos[1] + 1.5, str(task.order_number)) # Plot plt.draw() plt.pause(0.0001) plt.clf() plt.tight_layout()
import matplotlib.pyplot as plt import numpy as np import math a = np.loadtxt("/home/ljq/qt/RS_Lib/1.txt") f = plt.figure() ax = f.add_subplot(111) ax.set(xlim=[0, 10], ylim=[0, 10]) plt.plot(a[0, 0], a[0, 1], 'ro') plt.arrow(a[0, 0], a[0, 1], 1.0 * math.cos(a[0, 2]), 1.0 * math.sin(a[0, 2]), fc="r", ec="k", head_width=0.5, head_length=0.5) plt.plot(a[len(a) - 1, 0], a[len(a) - 1, 1], 'yo') plt.arrow(a[len(a) - 1, 0], a[len(a) - 1, 1], 1.0 * math.cos(a[len(a) - 1, 2]), 1.0 * math.sin(a[len(a) - 1, 2]), fc="r", ec="k", head_width=0.5, head_length=0.5) plt.plot(a[:, 0], a[:, 1], '-') plt.show()
def main(arg): if (len(arg)) == 1: print "Usage: {0} input\n".format(arg[0]) exit() p = 1 fig = plt.figure(figsize=(7, 7)) for file_in in arg[1:]: avg = [] # try: with open(file_in, "r") as csvfile: #sorry to use blah, but I blanked on a name for this latest temp dialect = csv.excel dialect.skipinitialspace = True blah = csv.reader(csvfile, dialect=dialect) for row in blah: r = map(float, row) avg.append(100.0*r[0]) if (len(avg) == 0): continue print len(avg) if (p <= 28): if (len(arg) == 2): ax = plt.subplot(1,1, p) else: ax = plt.subplot(7,4, p) #ax = plt.subplot(2,2, p) #plt.ylim(0,24) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width, box.height*0.8]) x_val = range(0, (len(avg))) x_val_exp = [] for x in x_val: x_val_exp.append(math.pow(2, x+10)) plt.plot(x_val_exp, avg) if (len(arg) == 2): plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.rc('font', size=12) else: plt.xticks(fontsize=5) plt.yticks(fontsize=5) plt.rc('font', size=5) ax.set_xscale('log', basex=2) #plt.ticklabel_format(axis='x', style='plain') for tick in ax.xaxis.get_major_ticks(): tick.label.set_rotation('vertical') if 0 == 1: #Approach 2 - Project points based on a uniformly decreasing line ideal_m = (avg[-1] - avg[0]) / len(avg) culum = avg[0] proj = [] for a in avg: proj.append(a - culum) culum += ideal_m accel = [] last = 0 for pr in proj: accel.append(pr - last) last = pr #plt.plot(range(10,10 + (len(avg))), proj) #plt.plot(range(10,10 + (len(avg))), accel) i = 0 last = 0 first_green = 0 first_red = 0 for a in accel: if i == 0: i += 1 last = a continue if last / a < 0: #is last > 0 and a < 0 or vis versa if (a > 0): c = 'r' if (first_red == 0): first_red = i else: c = 'g' if (first_green == 0): first_green = i # plt.axvline(i - 1 + 10, linewidth=1.25, color=c) last = a i += 1 arrow_pt = 0 if (first_green == 0 or first_red < first_green): arrow_pt = first_red else: arrow_pt = first_green if (arrow_pt < 3): arrow_pt = 3 arrow_val = avg[arrow_pt] arrow_pt = math.pow(2, arrow_pt) plt.arrow(arrow_pt, arrow_val, arrow_pt, arrow_val + 1) plt.axvline(arrow_pt, linewidth=1.25, color='r') harmony_l = file_in.split('/') file_in = harmony_l[-1] harmony_l = file_in.split('.') file_in = harmony_l[-2] plt.title(file_in, fontsize=5) p += 1 # plt.subplots_adjust(left=0.1, right =(0.1*max_threads)) plt.savefig( "temp.pdf") plt.savefig( "temp.png")