def checkOverlap(flag, n, a1, b1, a2, b2): ## Generate the sets of points and find their hulls if flag: setA = generateUniform(n, a1, b1) setB = generateUniform(n, a2, b2) else: setA = generateNormal(n, a1, b1) setB = generateNormal(n, a2, b2) hullA = jarvisMarch(setA) hullB = jarvisMarch(setB) ## Do all the plotting setAx, setAy = extractCoords(setA) setBx, setBy = extractCoords(setB) hullAx, hullAy = extractCoords(hullA) hullBx, hullBy = extractCoords(hullB) plt.plot(setAx, setAy, 'b.') plt.plot(setBx, setBy, 'c.') plt.plot(hullAx, hullAy, 'ro') plt.plot(hullBx, hullBy, 'mo') ## Approximate the centers of the hulls centerA = (avg(hullAx), avg(hullAy)) centerB = (avg(hullBx), avg(hullBy)) ## Find the maximum radii of the hulls and add the bounding ## circles to the plot rA = radius(centerA, hullA) rB = radius(centerB, hullB) circleA = plt.Circle(centerA, rA, color='r', fill=False) circleB = plt.Circle(centerB, rB, color='m', fill=False) ax = plt.gca() ax.add_patch(circleA) ax.add_patch(circleB) plt.axis('scaled') plt.show() ## If the distance between the centers is less than the sum ## of the radii the circles overlap if rA + rB >= dist(centerA, centerB): return 1 return 0
def draw_neural_net(ax, left, right, bottom, top, layer_sizes): ''' 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 ''' n_layers = len(layer_sizes) v_spacing = (top - bottom) / float(max(layer_sizes)) h_spacing = (right - left) / float(len(layer_sizes) - 1) # 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 / 4., color='w', ec='k', zorder=4) ax.add_artist(circle) # Edges 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') ax.add_artist(line)
def __init__(self, nodeid, bs, period, packetlen): self.nodeid = nodeid self.period = period self.bs = bs self.x = 0 self.y = 0 # this is very complex prodecure for placing nodes # and ensure minimum distance between each pair of nodes found = 0 rounds = 0 global nodes while (found == 0 and rounds < 100): a = random.random() b = random.random() if b<a: a,b = b,a posx = b*maxDist*math.cos(2*math.pi*a/b)+bsx posy = b*maxDist*math.sin(2*math.pi*a/b)+bsy if len(nodes) > 0: for index, n in enumerate(nodes): dist = np.sqrt(((abs(n.x-posx))**2)+((abs(n.y-posy))**2)) if dist >= 10: found = 1 self.x = posx self.y = posy else: rounds = rounds + 1 if rounds == 100: print ("could not place new node, giving up") exit(-1) else: print ("first node") self.x = posx self.y = posy found = 1 self.dist = np.sqrt((self.x-bsx)*(self.x-bsx)+(self.y-bsy)*(self.y-bsy)) print('node %d' %nodeid, "x", self.x, "y", self.y, "dist: ", self.dist) self.packet = myPacket(self.nodeid, packetlen, self.dist) self.sent = 0 # graphics for node global graphics if (graphics == 1): global ax ax.add_artist(plt.Circle((self.x, self.y), 2, fill=True, color='blue'))
def Gershgorin(self): if is_square(self.x) != True: print('Please enter a square matrix') return [] else: row_sum = [] list_diagonals = [] list_diagonals.append(np.array(self.x).diagonal()) self.x = np.absolute(self.x) row_sum.append( np.array(self.x).sum(axis=1) - np.array(self.x).diagonal()) y, z = row_sum, list_diagonals z = np.array(z).tolist() y = np.array(y).tolist() circles = list(map(list, zip(z[0], y[0]))) index, radi = zip(*circles) Xupper = max(index) + np.std(index) Xlower = min(index) - np.std(index) Ylimit = max(radi) + np.std(index) fig, ax = plt.subplots() ax = plt.gca() ax.cla() ax.set_xlim((Xlower, Xupper)) ax.set_ylim((-Ylimit, Ylimit)) plt.xlabel('Real Axis') plt.ylabel('Imaginary Axis') plt.title('Gershgorin circles') for x in range(0, len(circles)): circ = plt.Circle((index[x], 0), radius=radi[x]) ax.add_artist(circ) ax.plot([Xlower, Xupper], [0, 0], 'k--') ax.plot([0, 0], [-Ylimit, Ylimit], 'k--') ax.yaxis.grid(True, linestyle="--") ax.xaxis.grid(True, linestyle="--") for i in index: plt.axvline(x=i, linestyle='--', color='r') # vertical lines plt.show()
def sim_pi(total_sim): np.random.seed( 0 ) #creating a random seed to save the previous random numbers generated x_new = [] #creating an empty list for x values y_new = [] #creating an empty list for y values circle = [ ] #creating an empty list to save the values that fall inside the circle radius = 0.5 cir_plot = plt.Circle((0.5, 0.5), 0.5, color='r', fill=False) #plotting a circle sq_plot = plt.Rectangle((0, 0), 1, 1, color='b', fill=False) #plotting a rectangle fig = plt.gcf() ax = fig.gca(adjustable='box') ax.set_aspect('equal') ax.add_artist(cir_plot) ax.add_artist(sq_plot) dots = 0 for i in np.arange(total_sim): x = np.random.rand(1, 1) y = np.random.rand(1, 1) x_new = np.append(x_new, x) y_new = np.append(y_new, y) if (x - 0.5)**2 + (y - 0.5)**2 < radius**2: circle = np.append(circle, "red") dots += 1 else: circle = np.append(circle, "blue") plot = plt.scatter(x_new, y_new, s=1.5, color=circle) pi_val = (dots / total_sim) * 4 diff = round(abs(pi_val - 3.14159), 4) print("This simulation gives a pi value of", str(pi_val) + ". The difference between the known pi value of", str(3.14) + " and our simulated value is", str(diff) + ".")
def checkCircle(data): import matplotlib as plot # Transform data by rotation so that all data appears in the firt and # second quadrants (so that positive square root solution is valid) rot = np.arctan2(data[-1, 1] - data[0, 1], data[-1, 0] - data[0, 0]) R = getRotMat(rot + np.pi) trans = np.matmul(data, R) trans[:, 1] *= -1 # Display transformed data used for the actual fit plot.figure(2) plot.clf() plot.plot(trans[:, 0], trans[:, 1], '*') plot.axis("equal") thresh = 0.01 E = 10 count = 0 # Perform gradient descent up to four times with slightly different guesses # until a low E solution is found. while E > thresh and count < 4: count += 1 xBar = np.mean(trans[:, 0]) * (0.95 + np.random.rand(1) * 0.1)[0] yBar = np.min(trans[:, 1]) * (0.95 + np.random.rand(1) * 0.1)[0] rBar = np.abs((trans[0, 0] - trans[-1, 0]) / 2) * (0.95 + np.random.rand(1) * 0.1)[0] x0, y0, r, E = descent(trans, xBar, yBar, rBar) print(E) # More plotting of transformed data circle = plot.Circle((x0, y0), r, color='r', fill=False) plot.gca().add_artist(circle) # Rotate back to original coordinates y0 *= -1 center = np.matmul([x0, y0], np.linalg.inv(R)) if E < thresh: return center, r else: return None, None
def udaljenost_tocke(x1,y1,x2,y2,r): plt.xlim([0,10]) plt.ylim([0,10]) kruznica = plt.Circle((x2,y2),r,color='r') plt.gca().add_artist(kruznica) plt.plot(x1,y1, 'bo') x = (x1-x2)**2 + (y1-y2)**2 d = sqrt(x) nacin = int(input('Unesi 1 za prikaz slike, 2 za spremanje')) if znak ==1: plt.show() elif znak ==2: naziv = input('Unesite naziv slike:') plt.savefig(f'{naziv}.pdf') epsilon = 0.01 if d < r: print(f'Točka je unutar kružnice, a udaljenost je {d}.') elif r-epsilon < d < r+epsilon: print(f'Točka se nalazi na kružnici.') else: print(f'Točka je izvan kružnice, a udaljenost je {d}.')
def plot_station(fig, ax, station: Station, station_v_cat, C, scale, bar=True, scale_bar=10): i = station.ind node = station.node crd = node.crd station_v = [station_v_cat[:, 0], station_v_cat[:, 1:]] queue = station_v[0].cpu().numpy() scalex, scaley = scale font_size = scaley * 800 ax.add_patch(plt.Circle(crd, radius=30, color=C[i])) ax.text(crd[0], crd[1] - 70, "{}".format(int(sum(queue))), ha='center', va='center', fontsize=font_size) if bar: bar_scale_x = scalex * 10 bar_scale_y = scaley * 10 crd_base_bar = [crd[0], crd[1] + 40] pix_crd_base_bar = ax.transData.transform(crd_base_bar) bar_x, bar_y = ax.transAxes.inverted().transform(pix_crd_base_bar) ax_bar = fig.add_axes( [bar_x - bar_scale_x / 2, bar_y, bar_scale_x, bar_scale_y * 10]) ax_bar.bar(np.arange(len(queue)), queue, color=C) ax_bar.set_ylim(0, scale_bar * 10) ax_bar.axis('off')
Emax = 3 E = sqrt(vx**2 + vy**2) k = find(E.flat[:]>Emax) vx.flat[k] = nan vy.flat[k] = nan # plot vecor field quiver(x, y, vx, vy, pivot='middle', headwidth=4, headlength=6) xlabel('$x$') ylabel('$y$') axis('image') fig = plt.gcf() beacon1 = plt.Circle(beaXY,bR, color='g', fill=True) fig.gca().add_artist(beacon1) bealin1 = FancyArrowPatch((beaXY[0] - 2 * bR, beaXY[1]),(beaXY[0] + 2*bR, beaXY[1]), arrowstyle = '-', mutation_scale=1) fig.gca().add_artist(bealin1) bealin2 = FancyArrowPatch((beaXY[0], beaXY[1] - 2 * bR),(beaXY[0], beaXY[1] + 2 * bR), arrowstyle = '-', mutation_scale=1) fig.gca().add_artist(bealin2) desiredRadius = plt.Circle(beaXY, dR, color='b', fill=False, linestyle='dashdot') fig.gca().add_artist(desiredRadius) sensorRadius = plt.Circle(beaXY, sR, color='g', fill=False, linestyle='dashdot') fig.gca().add_artist(sensorRadius) desiredDistToRobot = plt.Circle(robXY, dD, color='b', fill=False, linestyle='dashdot') fig.gca().add_artist(desiredDistToRobot)
def Problem3(): import matplotlib.pyplot as plt import numpy as np import random import math random.seed() ntrials = 10 nwalks = 10 nsteps = 100000 MFP = .1 #mean free path r_circle = 10 #radius of circle d = np.array([]) d2 = np.array([]) ichoose = 0 if ichoose == 0: fig, ax = plt.subplots() else: fig, ax = plt.subplots(1, 2) for iwalk in range(nwalks): xpos = 0 ypos = 0 rpos = 0 nstep = np.array([]) xarr = np.array([]) yarr = np.array([]) nstep = np.append(nstep, 0) xarr = np.append(xarr, xpos) yarr = np.append(yarr, ypos) count = 1 xpos = 0 ypos = 0 d2pos = 0 for step in range(nsteps): #generate theta between 0 and 2pi theta = 2 * np.pi * random.random() xpoint = MFP * np.cos(theta) ypoint = MFP * np.sin(theta) #normalize these so the length of the step is 1 xnorm = xpoint / np.sqrt(xpoint**2 + ypoint**2) ynorm = ypoint / np.sqrt(xpoint**2 + ypoint**2) #add xnorm to xpos, ynorm to ypos xpos += xnorm ypos += ynorm r = np.sqrt(xpos**2 + ypos**2) count += 1 xarr = np.append(xarr, xpos) #append xpos to the xarr array yarr = np.append(yarr, ypos) #append ypos to the yarr array nstep = np.append(nstep, count) #append count to the nstep array #conditions for reaching the edge of the circle if r >= r_circle: break else: continue if ichoose == 0: ax.plot(xarr, yarr, 'r') d = np.append(d, xpos) d2 = np.append(d2, (xpos**2 + ypos**2)) #print the average amount of steps it takes to reach the edge of the circle print("the average number of steps is " + "{:.0f}".format(np.average(nstep))) #graph it just because it lpoks cool if ichoose == 0: circle = plt.Circle((0, 0), 10) ax.set(title='title', xlabel='steps', ylabel='distance') ax.set_xlim(-15., 15.) ax.set_ylim(-15., 15.) ax.add_artist(circle) ax.grid() plt.savefig("circlewalks.png") plt.show() elif ichoose == 1: ax[0].hist(d, bins=50, range=(-15., 15.), histtype='step') ax[0].set(title='title', xlabel='xpos', ylabel='number') ax[0].grid() print(np.mean(d2)) ax[1].hist(d2, bins=50, range=(0., 1000.), histtype='step') ax[1].set(title='title', xlabel='displacement**2', ylabel='number') ax[1].grid() plt.savefig("circlewalks.png") plt.show()
for j, dz in enumerate(tide.normdz): if switch[j]: ax2.plot(tide.norme, dz, '-r', linewidth=0.5, alpha=0.3) print tide.name[j] else: ax2.plot(tide.norme, dz, '-k', linewidth=0.5, alpha=0.3) ax2.plot(columbia.norme, columbia.normdz[0], '--k', linewidth=1., alpha=0.6) ax2.plot(hubbard.norme, hubbard.normdz[0], '-.k', linewidth=1., alpha=0.6) ax.plot(wolverine.norme, wolverine.normdz[0], '--k', linewidth=1., alpha=0.6) ax.plot(gulkana.norme, gulkana.normdz[0], '-.k', linewidth=1., alpha=0.6) #PLOTTING FLUXES AS CIRCLES termidz = [dz[0] for dz in tide.normdz] for i, flx in enumerate(tide.eb_bm_flx.astype(float)): circle1 = plt.Circle([0, termidz[i]], flx**0.5 / 10, color='r', zorder=-1) pth = ax2.add_patch(circle1) plt.show() fig.savefig( "/Users/igswahwsmcevan/Papers/AK_altimetry/Figures/dhdtprofiles.jpg", dpi=500) #plt.legend(loc=4,fontsize=11) #sort = N.argsort([dz[2] for dz in data.normdz]) #print data.name[sort[0]],data.name[sort[1]],data.name[sort[2]],data.name[sort[0]],data.name[sort[-2]],data.name[sort[-1]] #print data.name[sort[0]], data.norme[25], data.normdz[sort[0]][25] #ax.annotate(data.name[sort[0]], xy=(data.norme[25], data.normdz[sort[0]][25]), xytext=(0.4, -8),arrowprops=dict(facecolor='black', headwidth=6, width=0.4,shrink=0.02)) #ax.annotate(data.name[sort[1]], xy=(data.norme[20], data.normdz[sort[1]][20]), xytext=(0.4, -6),arrowprops=dict(facecolor='black', headwidth=6, width=0.4,shrink=0.02))
import numpy as np import matplotlib as plt matplotlib.use('Agg') import matplotlib.pyplot as plt #Descargar y almacenar los datos de Canal_ionico.txt data = np.genfromtxt("Canal_ionico.txt") #Hacer una grafica del corculo maximo obtenido y de las posiciones en xy (ver figura). #Guardar dicha grafica sin mostrarla en Canal.png. fig, ax = plt.subplots() plt.axis('equal') circle1 = plt.Circle(data[:,0], data[:,1], np.max(r_walk), color ='r',fill=False) ax.add_artist(circle1) plt.savefig("Canal.png") plt.close()
from matplotlib.gridspec import GridSpec import matplotlib.pyplot as plt get_ipython().run_line_magic('matplotlib', 'inline') # In[23]: labels = list(data1['AgeGroup']) sizes = list(data1['TotalCases']) explode = [] for i in labels: explode.append(0.05) plt.figure(figsize= (15,10)) plt.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=9, explode =explode) centre_circle = plt.Circle((0,0),0.70,fc='white') fig = plt.gcf() fig.gca().add_artist(centre_circle) plt.title('India - Age Group wise Distribution',fontsize = 20) plt.axis('equal') plt.tight_layout() # ## Importing and Reading the Dataset # HospitalBedsIndia.csv # In[24]: data2 = pd.read_csv(r"D:\DATA SCIENCE\Covid19 analysis\557629_1323860_bundle_archive\HospitalBedsIndia.csv")
x, y = meshgrid(x, y) # calculate vector field #vx = -y/sqrt(x**2+y**2)*exp(-(x**2+y**2)) #vy = x/sqrt(x**2+y**2)*exp(-(x**2+y**2)) #repulsor do beacon #vx = x - beaXY[0] #vy = y - beaXY[1] #atrator do beacon #vx = -x + beaXY[0] #vy = -y + beaXY[1] #rotacao no beacon anti-horaria vx = -(y - beaXY[1]) vy = x - beaXY[0] # plot vecor field quiver(x, y, vx, vy, pivot='middle', headwidth=4, headlength=6) xlabel('$x$') ylabel('$y$') axis('image') fig = plt.gcf() beacon1 = plt.Circle(beaXY, bR, color='g', fill=True) fig.gca().add_artist(beacon1) show() savefig('visualization_vector_fields_1.png')
rotx, roty = rotacionador(x, y, beaXY[0], beaXY[1], dR, 0.1) atrx, atry = atrator(x, y, beaXY[0], beaXY[1], dR, sR) repx, repy = repulsor(x, y, beaXY[0], beaXY[1], dR) vx = rotx + (atrx + repx) / 2 vy = roty + (atry + repy) / 2 # plot vecor field quiver(x, y, vx, vy, pivot='middle', headwidth=4, headlength=6) xlabel('$x$') ylabel('$y$') axis('image') fig = plt.gcf() beacon1 = plt.Circle(beaXY, bR, color='g', fill=True) fig.gca().add_artist(beacon1) bealin1 = FancyArrowPatch((beaXY[0] - 2 * bR, beaXY[1]), (beaXY[0] + 2 * bR, beaXY[1]), arrowstyle='-', mutation_scale=1) fig.gca().add_artist(bealin1) bealin2 = FancyArrowPatch((beaXY[0], beaXY[1] - 2 * bR), (beaXY[0], beaXY[1] + 2 * bR), arrowstyle='-', mutation_scale=1) fig.gca().add_artist(bealin2) desiredRadius = plt.Circle(beaXY, dR,
def main(): file_name = 'simpleattack-random-NNdefense' num_trials = 1 method = 'random-out' # method = 'nearest-out' # defense_method = 'grid' defense_method = 'NN' # defense_method = 'none' radius = 2.45 target = [3, 1] attacker_percentage = .25 max_iterations = 10000 plot_num = max_iterations / 10 data_window = 200 buffer_window = 50 num_neighbors = 10 avg_precision = [] avg_recall = [] avg_false_positives = [] avg_false_negatives = [] avg_iterations = [] for tr in range(num_trials): data = Dataset(p=2, n=10000, phi=0.05) data.generate_data(standard=True) (min_x, min_y) = np.min(data.X, axis=0) (max_x, max_y) = np.max(data.X, axis=0) min_x -= 10 min_y -= 10 max_x += 10 max_y += 10 xFine = 100 yFine = 100 thresh = 0.01 m = mesh(min_x, max_x, min_y, max_y, xFine, yFine, radius=.05) if defense_method == 'grid': detector = Anomaly_Detector(method, data.X[:1], data.Y[:1], radius, data_window, NNdefense_on=False) for t in data[1:]: old_center = detector.get_center() detector.add_point(np.reshape(t.X, (1, len(t))), t.Y) new_center = detector.get_center() m.addLine(old_center, new_center) detector.set_grid_width(m.width) baseline = m.percentage() m.center = detector.get_center() m.mode = 'test' if defense_method == 'NN': detector = Anomaly_Detector(method, data.X, data.Y, radius, data_window, time_window=buffer_window, percent=attacker_percentage, NN=num_neighbors, NNdefense_on=True) if defense_method == 'none': detector = Anomaly_Detector(method, data.X, data.Y, radius, data_window, NNdefense_on=False) normal_pts = [] iterations = 0 for k in range(max_iterations): iterations += 1 print iterations old_center = detector.get_center() if random.random() < attacker_percentage: if method == 'random-out' or method == 'average-out': new_point = simple_attack(detector.get_data(), target, detector.get_r()) else: new_point = greedy_optimal_attack(detector.get_data(), target, detector.get_r()) new_point = np.reshape(new_point, (1, len(new_point))) detector.add_point(new_point, 2) else: pt = data.generate_new_points(1) (true_value, new_point) = (pt[0], pt[1][0]) normal_pts.append((new_point, true_value)) new_point = np.reshape(new_point, (1, len(new_point))) detector.add_point(new_point, true_value) if defense_method == 'grid': new_center = detector.get_center() m.addLine(old_center, new_center) c, w = m.checkPoints(baseline, thresh) for cen in c: detector.add_grid_center(cen) rec = detector.get_grid_centers() w = detector.get_grid_width() w = w / 2 line = [old_center, new_center] recs = [] for r in rec: x1 = r[0] - w x2 = r[0] + w y1 = r[1] - w y2 = r[1] + w recs.append([[x1, y1], [x2, y2]]) should_delete = False for r in recs: if m.line_rec_intersection(line, r): should_delete = True if should_delete: detector.remove_point() if (k % plot_num) == 0: fig = plt.figure() ax = fig.add_subplot(1, 1, 1) circ = plt.Circle(detector.get_center(), radius, fill=False) ax.add_patch(circ) plt.scatter(target[0], target[1], color='g', marker='x', s=35, label='target point') plt.scatter(detector.get_data()[detector.get_labels() == True, 0], detector.get_data()[detector.get_labels() == True, 1], color='r', marker='o', s=10, label='anomalous points') plt.scatter(detector.get_data()[detector.get_labels() == False, 0], detector.get_data()[detector.get_labels() == False, 1], color='k', marker='+', s=20, label='nominal points') if attacker_percentage > 0: plt.scatter(detector.get_data()[detector.get_labels() == 2, 0], detector.get_data()[detector.get_labels() == 2, 1], color='b', marker='^', s=10, label='attack points') plt.xlim([-5, 5]) plt.ylim([-5, 5]) plt.gca().set_aspect('equal', adjustable='box') # plt.axis('equal') # plt.legend(loc=0) fig.savefig(file_name + get_new_num() + '.png', bbox_inches='tight') # plt.show() if detector.classify_point(target): print 'Target achieved' print detector.get_center() break normal_pts = np.array(normal_pts) true_positive = 0 true_negative = 0 false_positive = 0 false_negative = 0 X = [] Y = [] true_y = [] for n in normal_pts: X.append(n[0]) Y.append(detector.classify_point(n[0])) true_y.append(n[1]) if detector.classify_point(n[0]) and not n[1]: true_negative += 1 if detector.classify_point(n[0]) and n[1]: false_negative += 1 if not detector.classify_point(n[0]) and not n[1]: false_positive += 1 if not detector.classify_point(n[0]) and n[1]: true_positive += 1 print 'Number of iterations: ', iterations print 'True positive: ', true_positive print 'True negative: ', true_negative print 'False positive: ', false_positive print 'False negative: ', false_negative avg_iterations.append(iterations) avg_recall.append( float(true_positive) / (true_positive + false_negative)) avg_precision.append( float(true_positive) / (true_positive + false_positive)) avg_false_positives.append( float(false_positive) / (false_positive + true_negative)) avg_false_negatives.append( float(false_negative) / (false_negative + true_positive)) avg_iterations = np.array(avg_iterations) avg_recall = np.array(avg_recall) avg_precision = np.array(avg_precision) avg_false_positives = np.array(avg_false_positives) avg_false_negatives = np.array(avg_false_negatives) print 'Average iterations: ', np.mean(avg_iterations) print 'Average recall: ', np.mean(avg_recall) print 'Average precision: ', np.mean(avg_precision) print 'Average false positives: ', np.mean(avg_false_positives) print 'Average false negatives: ', np.mean(avg_false_negatives)
def pitch(ax): # size of the pitch is 120, 80 #Create figure #Pitch Outline & Centre Line plt.plot([0, 0], [0, 80], color="black") plt.plot([0, 120], [80, 80], color="black") plt.plot([120, 120], [80, 0], color="black") plt.plot([120, 0], [0, 0], color="black") plt.plot([60, 60], [0, 80], color="black") #Left Penalty Area plt.plot([14.6, 14.6], [57.8, 22.2], color="black") plt.plot([0, 14.6], [57.8, 57.8], color="black") plt.plot([0, 14.6], [22.2, 22.2], color="black") #Right Penalty Area plt.plot([120, 105.4], [57.8, 57.8], color="black") plt.plot([105.4, 105.4], [57.8, 22.5], color="black") plt.plot([120, 105.4], [22.5, 22.5], color="black") #Left 6-yard Box plt.plot([0, 4.9], [48, 48], color="black") plt.plot([4.9, 4.9], [48, 32], color="black") plt.plot([0, 4.9], [32, 32], color="black") #Right 6-yard Box plt.plot([120, 115.1], [48, 48], color="black") plt.plot([115.1, 115.1], [48, 32], color="black") plt.plot([120, 115.1], [32, 32], color="black") #Prepare Circles centreCircle = plt.Circle((60, 40), 8.1, color="black", fill=False) centreSpot = plt.Circle((60, 40), 0.71, color="black") leftPenSpot = plt.Circle((9.7, 40), 0.71, color="black") rightPenSpot = plt.Circle((110.3, 40), 0.71, color="black") #Draw Circles ax.add_patch(centreCircle) ax.add_patch(centreSpot) ax.add_patch(leftPenSpot) ax.add_patch(rightPenSpot) #Prepare Arcs # arguments for arc # x, y coordinate of centerpoint of arc # width, height as arc might not be circle, but oval # angle: degree of rotation of the shape, anti-clockwise # theta1, theta2, start and end location of arc in degree leftArc = Arc((9.7, 40), height=16.2, width=16.2, angle=0, theta1=310, theta2=50, color="black") rightArc = Arc((110.3, 40), height=16.2, width=16.2, angle=0, theta1=130, theta2=230, color="black") #Draw Arcs ax.add_patch(leftArc) ax.add_patch(rightArc)
Lpl = Ptx - minsensi maxDist = d0*(math.e**((Lpl-Lpld0)/(10.0*gamma))) # base station placement bsx = maxDist+10 bsy = maxDist+10 xmax = bsx + maxDist + 20 ymax = bsy + maxDist + 20 # prepare graphics and add sink if (graphics == 1): plt.ion() plt.figure() ax = plt.gcf().gca() # XXX should be base station position ax.add_artist(plt.Circle((bsx, bsy), 3, fill=True, color='green')) ax.add_artist(plt.Circle((bsx, bsy), maxDist, fill=False, color='green')) for i in range(0,nrNodes): # myNode takes period (in ms), base station id packetlen (in Bytes) # 1000000 = 16 min node = myNode(i,bsId, avgSendTime,20) nodes.append(node) for i in nodes: env.process(transmit(env,i)) #prepare show if (graphics == 1): plt.xlim([0, xmax]) plt.ylim([0, ymax])