Example #1
0
def gen_bars(data, headers, datasets, methods):
    """
    Description:
    Inputs:
    Outputs:
    """
    width = 0.5
    x = np.arange(0, 16, 2)
    
    labels_x = datasets.copy()
    labels_x.insert(0,"") 
    
    fig, ax = plt.subplots()
    bar1 = ax.bar(x - (0.3 + width/2), data[0,:], width, label = methods[0])
    add_labels(ax, bar1)

    if (len(methods) > 1):
        bar2 = ax.bar(x , data[1,:], width, label = methods[1])
        add_labels(ax, bar2)
    
        if (len(methods) > 2):
            bar3 = ax.bar(x + (0.3 + width/2), data[1,:], width, label = methods[2])
            add_labels(ax, bar3)

    ax.set_ylabel(metric)
    ax.set_xlabel("Dataset")
    
    ax.set_xticklabels(labels_x)
    ax.set_title(metric + " Across Datasets")
    ax.legend(bbox_to_anchor=(1, 1.15), fancybox=True, framealpha=0.5)
Example #2
0
 def redo_axes_ticks(self, axes:matplotlib.axes.Axes, x_len:int, y_len:int):
     downsample = self.w_downsample.value()
     x_stops = np.linspace(0, x_len, 6)
     x_stops_downsampled = x_stops / downsample
     axes.set_xticks(x_stops_downsampled)
     axes.set_xticklabels(["%d" % x for x in x_stops])
     y_stops = np.linspace(0, y_len, 6)[::-1]
     y_stops_downsampled = y_stops / downsample
     axes.set_yticks(y_stops_downsampled)
     axes.set_yticklabels(["%d" % y for y in y_stops])
Example #3
0
def club_tags(unencoded_clubs_list):
    """
    Creates a bar graph showing of the number of occurrances of each possible club tag.
    
    By using a dictionary to count club tag occurrances, the function then creates a 
    matplotlib bar graph using numpy representations of the dictionary information.
    The graph is formatted and pushed as a Response type for view on the server.
    
    Returns:
    --------
    Response
        The graph
    """

    club_dict = {}
    for clubs in unencoded_clubs_list:
        for tag in clubs.get_category():
            if tag in club_dict:
                club_dict[tag] = club_dict[tag] + 1
            else:
                club_dict[tag] = 1
    x = np.zeros(len(club_dict))
    index_counter = 0
    for tag in club_dict:
        x[index_counter] = club_dict.get(tag)
        index_counter = index_counter + 1

    fig = plt.figure()
    ax = fig.add_subplot()
    bar = ax.bar(np.arange(len(club_dict)), x)
    labels = club_dict.keys()
    ax.set_xticks(np.arange(len(club_dict)))
    ax.set_xticklabels(labels, rotation='45', ha='right')
    ax.set_xlabel('Club Tags')
    ax.set_ylabel('Number of Occurrances')
    ax.set_title('Number of Club Tag Occurrances')
    for rect in bar:
        height = rect.get_height()
        ax.annotate('{}'.format(height),
                    xy=(rect.get_x() + rect.get_width() / 2, height),
                    xytext=(0, 3),
                    textcoords="offset points",
                    ha='center',
                    va='bottom')

    plt.tight_layout()
    output = io.BytesIO()
    FigureCanvas(fig).print_png(output)
    return Response(output.getvalue(), mimetype='image/png')
Example #4
0
def clubs_per_user(user_list):
    """
    Creates a bar graph of the number of clubs per user. 
    
    Using a dictionary to gather each user's name and the number of club each 
    user is in, numpy representations of the data is used to create a matplotlib
    bar graph. The graph is then formatted and pushed for view on the server.
    
    Returns:
    --------
    Response
        The graph
    """
    user_club_dict = {}
    for user in user_list:
        name = user.get_user_name()
        user_club_dict[name] = len(user.get_user_clubs())

    x = np.zeros(len(user_club_dict))
    index_counter = 0
    for user in user_club_dict:
        x[index_counter] = user_club_dict.get(user)
        index_counter = index_counter + 1

    fig = plt.figure()
    ax = fig.add_subplot()
    bar = ax.bar(np.arange(len(user_club_dict)), x)
    labels = user_club_dict.keys()
    ax.set_xticks(np.arange(len(user_club_dict)))
    ax.set_xticklabels(labels, rotation='45', ha='right')
    ax.set_xlabel('User Name')
    ax.set_ylabel('Number of Clubs')
    ax.set_title('Number of Clubs per User')
    for rect in bar:
        height = rect.get_height()
        ax.annotate('{}'.format(height),
                    xy=(rect.get_x() + rect.get_width() / 2, height),
                    xytext=(0, 3),
                    textcoords="offset points",
                    ha='center',
                    va='bottom')

    plt.tight_layout()
    output = io.BytesIO()
    FigureCanvas(fig).print_png(output)
    return Response(output.getvalue(), mimetype='image/png')
Example #5
0
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.axes as ax
import pylab

# change to proper directory
os.chdir('C:\Users\Matt\Desktop\Python Projects\Exploratory Data Analysis')

# load file, select proper date range, convert row to numeric dtypes
hpc = pd.read_csv('household_power_consumption.txt',
                  sep=';',
                  index_col=['Date'],
                  usecols=['Global_active_power', 'Date'])
# hpc = hpc.drop(['Date', 'Time'], axis=1).set_index('DT')
hpc = hpc['1/2/2007':'3/2/2007'].convert_objects(convert_numeric=True)
hpc = hpc[0:2881]
# create plotting variables
x = pd.date_range('2/1/2007', '2/3/2007 00:00', freq='T')
y = hpc['Global_active_power']
#plt.plot(y, color='k')

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(x, y, color='k')
ax.set_xticklabels(['Thur', '', '', '', 'Fri', '', '', '', 'Sat'])
ax.set_yticklabels(['0', '', '2', '', '4', '', '6'])
#plt.xlabel('Global Active Power (kilowatts)')
ax.set_ylabel('Global Active Power (kilowatts)')
#plt.title('Global Active Power')
pylab.show()
Example #6
0
domain_x = 20
domain_y = 20
iterations = 200

# Should not need to adjust anything below here
domain = np.genfromtxt(domain_file, skip_header=2)
pos_data = np.zeros(14)

dom_x, dom_y = domain.shape

for time in range(0, iterations):
    print(time)
    plt.figure()
    plt.title("Time = {0}".format(time))
    ax = plt.gca()
    ax.set_xticks(np.arange(-.5, 20, 1))
    ax.set_yticks(np.arange(-.5, 20, 1))
    ax.set_xticklabels(np.arange(0, 20, 1))
    ax.set_yticklabels(np.arange(0, 20, 1))
    plt.imshow(domain, cmap=cm.jet, interpolation='nearest')
    for i in range(0, cores):
        for j in range(0, int(seekers / cores)):

            filename = "PositionalData/pos_procseeker{0}_Iter{1}.dat".format(
                1000 * i + j, time)
            temp_plot = np.genfromtxt(filename)
            plt.plot(temp_plot[:, 0], temp_plot[:, 1], 'x')
    #plt.show()
    plt.savefig("PositionalData/Positions_{0}.png".format(time), dpi=200)
    plt.close()
import matplotlib.pyplot as plt
import matplotlib.axes as ax
from matplotlib.animation import FuncAnimation
from random import uniform, choice
import os

speeds = [
    0.08, -0.08, 0.07, -0.07, 0.06, -0.06, 0.05, -0.05, 0.04, -0.04, 0, 0
]

# ---------------------------CREATE FIGURES/PLOTS------------------------------

# Create upper graph
fig = plt.figure(figsize=(10, 8))
ax = plt.subplot(211)  # (rows, columns, plot index)
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xticks([])
ax.set_yticks([])

x_max = 10
y_max = 6
xy_min = 0

ax.set_xlim(right=x_max)
ax.set_ylim(top=y_max)

# Create bottom graph
ax2 = plt.subplot(212)
ax2.set_xlim(right=1000)
ax2.set_ylim(top=70)
    def _plot(self):
        self.figure.clear()
        self.canvas.draw()
        self.buttonSave.setEnabled(False)

        if self.pt is None and self.rectangle is None:
            return

        if self.parameter is None or self.coverage is None or self.dataset is None:
            return

        canvasLayers = []
        try:
            allCoverageLayers = layers._layers[self.dataset][self.coverage]
        except KeyError:
            return
        for layerdef in allCoverageLayers:
            source = layerdef.source()
            time = parser.parse(layerdef.time())
            try:
                layer = layerFromSource(source)
                canvasLayers.append((layerdef, time))
            except WrongLayerSourceException:
                pass

        if not canvasLayers:
            return

        minDate = None
        maxDate = None
        minY = None
        maxY = None
        if self.filter:
            if self.filter[0] is not None:
                minDate = self.filter[0]
            if self.filter[1] is not None:
                maxDate = self.filter[1]
            minY = self.filter[2] or None
            maxY = self.filter[3] or None

        try:
            bands = allCoverageLayers[0].bands()

            if self.rectangle is None:
                self.data = {}
                startProgressBar("Retrieving plot data", len(canvasLayers))
                for (i, (layerdef, time)) in enumerate(canvasLayers):
                    if ((minDate is not None and time < minDate)
                            or (maxDate is not None and time > maxDate)):
                        continue
                    start = timelib.time()
                    layer = layerdef.layer()
                    v = self.parameter.value(layer, self.pt, bands)
                    end = timelib.time()
                    logger.info(
                        "Plot data for layer %i retrieved in %s seconds" %
                        (i, str(end - start)))
                    setProgressValue(i + 1)
                    if v is not None:
                        self.data[time] = [(v, (self.pt.x(), self.pt.y()))]
                closeProgressBar()
                if not self.data:
                    return
                y = [v[0][0] for v in self.data.values()]
                ymin = min(y)
                ymax = max(y)
            else:
                self.data = {}
                startProgressBar("Retrieving plot data", len(canvasLayers))
                for (i, (layerdef, time)) in enumerate(canvasLayers):
                    if ((minDate is not None and time < minDate)
                            or (maxDate is not None and time > maxDate)):
                        continue
                    start = timelib.time()
                    layer = layerdef.layer()
                    if not self.rectangle.intersects(layer.extent()):
                        continue
                    rectangle = self.rectangle.intersect(layer.extent())
                    xsteps = int(rectangle.width() /
                                 layer.rasterUnitsPerPixelX())
                    ysteps = int(rectangle.height() /
                                 layer.rasterUnitsPerPixelY())
                    filename = layerdef.layerFile(rectangle)
                    roi = layers.getBandArrays(filename)
                    end = timelib.time()
                    logger.info(
                        "ROI data for layer %i retrieved in %s seconds" %
                        (i, str(end - start)))
                    start = timelib.time()
                    setProgressValue(i + 1)
                    self.data[time] = []
                    for col in range(xsteps):
                        x = rectangle.xMinimum(
                        ) + col * layer.rasterUnitsPerPixelX()
                        for row in range(ysteps):
                            y = rectangle.yMinimum(
                            ) + row * layer.rasterUnitsPerPixelY()
                            pixel = QgsPoint(col, row)
                            value = self.parameter.value(roi, pixel, bands)
                            if value:
                                self.data[time].append((value, (x, y)))
                    end = timelib.time()
                    logger.info(
                        "Plot data computed from ROI data in %s seconds" %
                        (str(end - start)))
                closeProgressBar()
                if not self.data:
                    return
                y = [[v[0] for v in lis] for lis in self.data.values()]
                ymin = min([min(v) for v in y])
                ymax = max([max(v) for v in y])

            xmin = min(self.data.keys())
            xmax = max(self.data.keys())

            if self.filter is None:
                self.plotDataChanged.emit(xmin, xmax, ymin, ymax)
            self.dataToPlot = copy.deepcopy(self.data)

            if self.filter:
                for key, values in self.data.iteritems():
                    for v in values[::-1]:
                        if ((minY is not None and v[0] < minY)
                                or (maxY is not None and v[0] > maxY)):
                            try:
                                self.dataToPlot[key].remove(v)
                            except:
                                pass

            datesToRemove = []
            for key, values in self.dataToPlot.iteritems():
                if not values:
                    datesToRemove.append(key)
            for d in datesToRemove:
                del self.dataToPlot[d]

            axes = self.figure.add_subplot(1, 1, 1)
            x = matplotlib.dates.date2num(self.dataToPlot.keys())
            if self.rectangle is None:
                y = [v[0][0] for v in self.dataToPlot.values() if v]
                axes.scatter(self.dataToPlot.keys(), y)
            else:
                sortedKeys = sorted(self.dataToPlot.keys())
                y = [[v[0] for v in self.dataToPlot[k]] for k in sortedKeys]
                axes.boxplot(y)
                axes.set_xticklabels(
                    [str(d).split(" ")[0] for d in sortedKeys], rotation=70)
            self.figure.autofmt_xdate()
        except Exception, e:
            traceback.print_exc()
            closeProgressBar()
            return
Example #9
0
for i in range(len(list_point_end_file)):
    if (list_point_end_file[i] >= cut_start) & (list_point_end_file[i] <
                                                cut_end):
        plt.axvline(list_point_end_file[i] - cut_start,
                    color='black',
                    linestyle='-',
                    linewidth=0.1)
        cut_lable.append(labels[i])
        cut_list_point.append(list_point_end_file[i] - cut_start)
        # print(labels[i])

# ax.set_xticks(list_point_end_file)
# ax.set_xticklabels(labels,rotation=60)
ax.set_xticks(cut_list_point)
ax.set_xticklabels(cut_lable, rotation=60)
fig = plt.gcf()
fig.set_size_inches(18, 5.5)
plt.ylabel('value')
plt.xlabel('Time')
# plt.show()

window = []
list_mean = []
list_up_variance = []
list_low_variance = []
for data in stream_data:
    if len(window) >= max_size:
        window.pop(0)
    window.append(data)
    mean = sum(window) / len(window)
import matplotlib.pyplot as plt
import matplotlib.axes as ax
import pylab

# change to proper directory
os.chdir('C:\Users\Matt\Desktop\Python Projects\Exploratory Data Analysis')

# load file, select proper date range, convert row to numeric dtypes
hpc = pd.read_csv('household_power_consumption.txt', sep=';', index_col=['Date'], usecols=['Sub_metering_1', 'Sub_metering_2', 'Sub_metering_3', 'Date'])
# hpc = hpc.drop(['Date', 'Time'], axis=1).set_index('DT')
hpc = hpc['1/2/2007':'3/2/2007'].convert_objects(convert_numeric=True)
hpc = hpc[0:2881]
# create plotting variables
x = pd.date_range('2/1/2007', '2/3/2007 00:00', freq='T')
y1 = hpc.Sub_metering_1
y2 = hpc.Sub_metering_2
y3 = hpc.Sub_metering_3

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(x, y1, color='k', label='Sub_metering_1')
ax.plot(x, y2, color='r', label='Sub_metering_2')
ax.plot(x, y3, color='b', label='Sub_metering_3')
ax.legend(loc='best')
ax.set_xticklabels(['Thur', '', '', '', 'Fri', '', '', '','Sat'])
ax.set_yticklabels(['0', '',  '10', '', '20', '', '30'])

#plt.xlabel('Global Active Power (kilowatts)')
ax.set_ylabel('Energy sub metering')
#plt.title('Global Active Power')
pylab.show()
Example #11
0
def create_bar_graph(data=[[[1, 2], [10, 20]]],
                     semilog=False,
                     add_bar_labels=True,
                     title='Insert Fancy Title',
                     add_legend=False,
                     bar_colors=[],
                     legend_labels=[]):
    import matplotlib.patches as mpatches
    from collections import deque
    if not bar_colors:
        bar_color_deque = deque([
            '#1395ba', '#a2b86c', '#ebc844', '#f16c20', '#c02e1d', '#0d3c55',
            '#ecaa38', '#117899', '#d94e1f', '#5ca793', '#ef8b2c', '#0f5b78'
        ])
    else:
        bar_color_deque = deque(bar_colors)
    width = 0.33
    xs = data[0][0]
    legend_labels_queue = deque(legend_labels)
    handles = []
    if len(data) > 1:
        width = 0.33 * 2 / len(data)
        #plot comparison from multiple archives
        all_unique_x = {}
        for series in data:
            for size in series[0]:
                all_unique_x[size] = True
        ind = np.arange(len(all_unique_x.keys()))
        rect_refs = []
        fig, ax = plt.subplots()
        bar_shift = width / 2
        #plot individual bars to allow for sparse data plots
        for series in data:
            if len(series) > 2:
                label = series[2]
            color = bar_color_deque.popleft()
            if legend_labels:
                legend_label = legend_labels_queue.popleft()
            else:
                legend_label = label
            handles.append(mpatches.Patch(color=color, label=legend_label))
            index = 0
            labeled_yet = False
            for ex in sorted(all_unique_x.keys()):
                for i in range(0, len(series[0])):
                    if series[0][i] == ex:
                        if 'label' in locals() and not labeled_yet:
                            rects = ax.bar(index + bar_shift,
                                           series[1][i],
                                           width,
                                           color=color,
                                           label=label)
                            labeled_yet = True
                        else:
                            rects = ax.bar(index + bar_shift,
                                           series[1][i],
                                           width,
                                           color=color)
                        rect_refs.append(rects[0])
                        if add_bar_labels:
                            bar_label(ax, rects, semilog)
                index += 1
            bar_shift += width
        if semilog:
            ax.set_yscale('log')
        ax.set_xticks(ind + 0.59 - 0.045 * len(data))
        if add_legend:
            plt.legend(handles=handles, loc=2)
    else:
        color = bar_color_deque.popleft()
        ys = data[0][1]
        ind = np.arange(len(xs))
        fig, ax = plt.subplots()
        rects = ax.bar(ind + width, ys, color=color)
        ax.set_xticks(ind + width * 2)
        if semilog:
            ax.set_yscale('log')
        if add_bar_labels:
            bar_label(ax, rects, semilog)
    fig.set_size_inches(15, 8)
    ax.set_xticklabels(xs, rotation=0)
    ax.set_title(title)
    ax.set_xlabel("Object Size (Bytes)")
    ax.set_ylabel('MB/s')
    plt.show()
    plt.savefig('foo.png')
    return
	plt.ylabel('Time of the Day')


	y = [y for y in range(6,144,6)]
	x = [x for x in range(0, global_count)]

	ax.set_yticks(y)
	ax.set_xticks(x)
	plt.xticks(rotation=50)
	for i in range(len(trip_IDs)):
		if i%5 != 0:
			trip_IDs[i]=""

	ax.set_xticklabels(trip_IDs)
	ax.set_yticklabels(ylabels)
	plt.tight_layout()
	plt.show()
	'''

	#plt.subplot()
	pos = np.arange(len(xlabels_slots))
	width = 1
	ax = plt.axes()
	ax.set_xticks(pos + (width/2))
	plt.xticks(rotation=50)
	ax.set_xticklabels(xlabels_slots)
	plt.bar(pos, frequencies[:23], width, color='r')
	plt.tight_layout()
	plt.gcf()
	plt.savefig('histogram' + file + '.png', bbox_inches='tight')
	#plt.show()
Example #13
0
labels = [label.replace('20140927', '') for label in labels]
stream_data = []
for test_file in test_files:
    dir = os.path.join(test_path, test_file)
    with open(dir) as txt_lines:
        list_point_end_file.append(len(stream_data))
        for line in txt_lines:
            stream_data.append(int(line.replace('\n', '')))
ax  = plt.subplot(111)
plt.plot(stream_data)
print(list_point_end_file)
for i in range(len(list_point_end_file)):
    plt.axvline(list_point_end_file[i], color='black', linestyle='-',linewidth=0.1)

ax.set_xticks(list_point_end_file)
ax.set_xticklabels(labels,rotation=60)
plt.ylabel('value')
plt.xlabel('Time')

plt.show()
window_size = 6000
loop = int(len(stream_data)/window_size)+1
print(loop)
start_point = 0
end_point = 0
print(len(stream_data))
change_points = []
for i in range(int(loop)):
    ax = plt.subplot(111)
    if(i == 0):
        start_point = 0
Example #14
0
    plt.close()

with PdfPages('ImagenFantasma_x_tamaƱo.pdf') as pdf:
    #plt.figure(figsize=(7, 5))
    labels = 'ASM', 'O3', 'O2', 'O0'
    barValues = [resASM[7],resC3[7],resC2[7],resC0[7]]
    x = [1,2,3,4]
    fig, ax = plt.subplots()
    rects1 = ax.bar(x, barValues,0.7, label='')
    plt.ylabel('')
    plt.xlabel("Implementaciones")
    plt.ylabel("Ciclos de clock")
    plt.title("Imagen Fantasma 1600x1200")
    ax.ticklabel_format(style='plain')
    ax.set_xticks(x)
    ax.set_xticklabels(labels)
    plt.grid(linestyle='-', linewidth=1, axis='y')
    pdf.savefig(bbox_inches='tight')
    plt.close()

def calcularPorcentaje(asm, c):
    return int((asm*100)/c)

for i in range(0,8):
    asm_vs_o3 = calcularPorcentaje(resASM[i], resC3[i])
    asm_vs_o2 = calcularPorcentaje(resASM[i], resC2[i])
    asm_vs_o0 = calcularPorcentaje(resASM[i], resC0[i])

    print(" ")
    print("imagenFantasma_asm_vs_O0: " + str(asm_vs_o0) + '%')
    print("imagenFantasma_asm_vs_O2: " + str(asm_vs_o2) + '%')