class OrbitPlotter3D(_BaseOrbitPlotter): """OrbitPlotter3D class. """ def __init__(self): super().__init__() self._layout = Layout( autosize=True, scene=dict( xaxis=dict( title="x (km)", ), yaxis=dict( title="y (km)", ), zaxis=dict( title="z (km)", ), aspectmode="data", # Important! ), ) def _plot_sphere(self, radius, color, name, center=[0, 0, 0] * u.km): xx, yy, zz = _generate_sphere(radius, center) sphere = Surface( x=xx.to(u.km).value, y=yy.to(u.km).value, z=zz.to(u.km).value, name=name, colorscale=[[0, color], [1, color]], cauto=False, cmin=1, cmax=1, showscale=False, # Boilerplate ) return sphere @u.quantity_input(elev=u.rad, azim=u.rad, distance=u.km) def set_view(self, elev, azim, distance=5 * u.km): x = distance * np.cos(elev) * np.cos(azim) y = distance * np.cos(elev) * np.sin(azim) z = distance * np.sin(elev) self._layout.update({ "scene": { "camera": { "eye": { "x": x.to(u.km).value, "y": y.to(u.km).value, "z": z.to(u.km).value } } } }) def _plot_trajectory(self, trajectory, label, color, dashed): trace = Scatter3d( x=trajectory.x.to(u.km).value, y=trajectory.y.to(u.km).value, z=trajectory.z.to(u.km).value, name=label, line=dict( color=color, width=5, dash='dash' if dashed else 'solid', ), mode="lines", # Boilerplate ) self._data.append(trace)
class OrbitPlotter2D(_BaseOrbitPlotter): """OrbitPlotter2D class. .. versionadded:: 0.9.0 """ def __init__(self): super().__init__() self._layout = Layout( autosize=True, xaxis=dict( title="x (km)", constrain="domain", ), yaxis=dict( title="y (km)", scaleanchor="x", ), ) self._layout.update({ "shapes": [] }) def _plot_sphere(self, radius, color, name, center=[0, 0, 0] * u.km): xx, yy = _generate_circle(radius, center) x_center, y_center, z_center = center trace = Scatter(x=xx.to(u.km).value, y=yy.to(u.km).value, mode='markers', line=dict(color=color, width=5, dash='dash',), name=name) self._layout["shapes"] += ( { 'type': 'circle', 'xref': 'x', 'yref': 'y', 'x0': (x_center - radius).to(u.km).value, 'y0': (y_center - radius).to(u.km).value, 'x1': (x_center + radius).to(u.km).value, 'y1': (y_center + radius).to(u.km).value, 'opacity': 1, 'fillcolor': color, 'line': { 'color': color, }, }, ) return trace def _plot_trajectory(self, trajectory, label, color, dashed): trace = Scatter( x=trajectory.x.to(u.km).value, y=trajectory.y.to(u.km).value, name=label, line=dict( color=color, width=2, dash='dash' if dashed else 'solid', ), mode="lines", # Boilerplate ) self._data.append(trace)
def _merge_layout(x: go.Layout, y: go.Layout) -> go.Layout: """Merge attributes from two layouts.""" xjson = x.to_plotly_json() yjson = y.to_plotly_json() if 'shapes' in yjson and 'shapes' in xjson: xjson['shapes'] += yjson['shapes'] yjson.update(xjson) return go.Layout(yjson)
def __init__(self, figure=None, dark=False): super().__init__(figure) self._layout = Layout( autosize=True, scene=dict( xaxis=dict(title="x (km)"), yaxis=dict(title="y (km)"), zaxis=dict(title="z (km)"), aspectmode="data", # Important! ), ) if dark: self._layout.template = "plotly_dark"
def __init__(self): super().__init__() self._layout = Layout( autosize=True, xaxis=dict( title="x (km)", constrain="domain", ), yaxis=dict( title="y (km)", scaleanchor="x", ), ) self._layout.update({ "shapes": [] })
def __init__(self): super().__init__() self._layout = Layout( autosize=True, scene=dict( xaxis=dict( title="x (km)", ), yaxis=dict( title="y (km)", ), zaxis=dict( title="z (km)", ), aspectmode="data", # Important! ), )
def GeneRegulationNetwork(self, netthreshold, config, netconfig): # Transpose the dataframe to get correct format to create the network dfT = self.dfz.transpose() # Get all the TF Gene names tf_names = list(dfT) # Create a Dask Client, just in case we want parellalize the algorithm client = Client(processes=False) # create dataframe network with columns --> TF, target Gene, Importance if netconfig == 1: network = grnboost2(expression_data=dfT, tf_names=tf_names, client_or_address=client) print("grnboost2") else: network = genie3(expression_data=dfT, tf_names=tf_names, client_or_address=client) # We put a threshold because we have a lot of conections and we want to obtain a clear graph with the most representatives conected genes limit = network.index.size * netthreshold G = nx.from_pandas_edgelist(network.head(int(limit)), 'TF', 'target', ['importance'], create_using=nx.Graph(directed=False)) N = len(list(G.node())) # number of genes nodes V = list(G.node()) # list of genes nodes Edges = list(G.edges()) layt = { 1: nx.fruchterman_reingold_layout(G, dim=3), 2: nx.circular_layout(G, dim=3) }.get(config, nx.circular_layout(G, dim=3)) laytN = list(layt.values()) Xn = [laytN[k][0] for k in range(N)] # x-coordinates of nodes Yn = [laytN[k][1] for k in range(N)] # y-coordinates Zn = [laytN[k][2] for k in range(N)] # z-coordinates Xe = [] Ye = [] Ze = [] for e in Edges: Xe += [layt[e[0]][0], layt[e[1]][0], None] # x-coordinates of edge ends Ye += [layt[e[0]][1], layt[e[1]][1], None] Ze += [layt[e[0]][2], layt[e[1]][2], None] trace1 = Scatter3d(x=Xe, y=Ye, z=Ze, mode='lines', line=Line(color='rgb(125,125,125)', width=1), hoverinfo='none') trace2 = Scatter3d(x=Xn, y=Yn, z=Zn, mode='markers+text', textposition='top center', name='genes', marker=Marker(symbol='circle', size=3, color='#6959CD', colorscale='Viridis', line=Line(color='rgb(50,50,50)', width=1)), text=V, hoverinfo='text') axis = dict(showbackground=False, showline=False, zeroline=False, showgrid=False, showticklabels=False, title='') fig = Figure(data=Data([trace1, trace2]), layout=Layout( title="Gene Regulatory Network", width=1000, height=1000, showlegend=False, scene=Scene( xaxis=XAxis(axis), yaxis=YAxis(axis), zaxis=ZAxis(axis), ), margin=Margin(t=100), hovermode='closest', annotations=Annotations([ Annotation(showarrow=False, text="Khaos Research Group", xref='paper', yref='paper', x=0, y=0.1, xanchor='left', yanchor='bottom', font=Font(size=20)) ]), )) plotly.offline.plot(fig, filename='3DNetworkx_.html', auto_open=True) script = plot(fig, output_type='div', include_plotlyjs=False, show_link=True) #print(script) return script
def draw_plot_graph(data, graph_title, textBaseDirName): plotly.offline.plot({ "data": data, "layout": Layout(title=graph_title) }, filename=textBaseDirName + "_plot.html")
name='top 10 TFs with p-value < 0.05', mode='markers', marker=dict(size=9, opacity=0.8), textfont=dict(family='sans serif', size=11, color='black'), text=list( map(lambda x: "%s\n%s" % ('CistromeDB:', x), final_top.loc[:, 'name_y'])), hoverinfo='text', textposition='top right') layout = Layout( title=title, xaxis=dict(title='-log10(p-value) of Gene Set 1' if labels1.strip() == '' else '-log10(p-value) of %s' % labels1, showgrid=False, titlefont=dict(family='Arial', size=20), rangemode='tozero', range=[0, xlim]), yaxis=dict(title='-log10(p-value) of Gene Set 2' if labels2.strip() == '' else '-log10(p-value) of %s' % labels2, showgrid=False, titlefont=dict(family='Arial', size=20), rangemode='tozero', range=[0, ylim]), hovermode='closest', width=850, height=650) fig = Figure(data=[top_trace0, trace1], layout=layout) plot(fig, filename='%s.html' % prefix, show_link=False, auto_open=False)
def plotClusters(data, dimensions): ''' This uses the plotly offline mode to create a local HTML file. This should open your default web browser. ''' if dimensions not in [2, 3]: raise Exception( "Plots are only available for 2 and 3 dimensional data") # Convert data into plotly format. traceList = [] for i, c in enumerate(data): # Get a list of x,y coordinates for the points in this cluster. cluster_data = [] for point in c.points: cluster_data.append(point.coords) trace = {} centroid = {} if dimensions == 2: # Convert our list of x,y's into an x list and a y list. trace['x'], trace['y'] = zip(*cluster_data) trace['mode'] = 'markers' trace['marker'] = {} trace['marker']['symbol'] = i trace['marker']['size'] = 12 trace['name'] = "Cluster " + str(i) traceList.append(Scatter(**trace)) # Centroid (A trace of length 1) centroid['x'] = [c.centroid.coords[0]] centroid['y'] = [c.centroid.coords[1]] centroid['mode'] = 'markers' centroid['marker'] = {} centroid['marker']['symbol'] = i centroid['marker']['color'] = 'rgb(200,10,10)' centroid['name'] = "Centroid " + str(i) traceList.append(Scatter(**centroid)) else: symbols = [ "circle", "square", "diamond", "circle-open", "square-open", "diamond-open", "cross", "x" ] symbol_count = len(symbols) if i > symbol_count: print("Warning: Not enough marker symbols to go around") # Convert our list of x,y,z's separate lists. trace['x'], trace['y'], trace['z'] = zip(*cluster_data) trace['mode'] = 'markers' trace['marker'] = {} trace['marker']['symbol'] = symbols[i] trace['marker']['size'] = 12 trace['name'] = "Cluster " + str(i) traceList.append(Scatter3d(**trace)) # Centroid (A trace of length 1) centroid['x'] = [c.centroid.coords[0]] centroid['y'] = [c.centroid.coords[1]] centroid['z'] = [c.centroid.coords[2]] centroid['mode'] = 'markers' centroid['marker'] = {} centroid['marker']['symbol'] = symbols[i] centroid['marker']['color'] = 'rgb(200,10,10)' centroid['name'] = "Centroid " + str(i) traceList.append(Scatter3d(**centroid)) title = "K-means clustering with %s clusters" % str(len(data)) plotly.offline.plot({"data": traceList, "layout": Layout(title=title)})
altcoin_coins = Scatter(x=blocks, y=calculate_coin_count(blocks), name='altcoin_coins') block_reward = Scatter(x=calculate_years(blocks), y=calculate_block_rewards(blocks), name='block_reward', xaxis='x2', yaxis='y2') data = [altcoin_coins, block_reward] layout = Layout(title='Altcoin Distribution Schedule', xaxis=dict(title='Blocks', titlefont=dict(color='rgb(148,103,189)'), tickfont=dict(color='rgb(148,103,189)'), domain=[0, .45]), xaxis2=dict(title='Year', titlefont=dict(color='rgb(148,103,189)'), tickfont=dict(color='rgb(148,103,189)'), domain=[.55, 1]), yaxis2=dict(title='Block Reward', titlefont=dict(color='rgb(253, 127, 40)'), tickfont=dict(color='rgb(253, 127, 40)'), anchor='x2', overlaying='y', side='right')) fig = Figure(data=data, layout=layout) plotly.offline.plot(fig, filename='index.html')
pair.append(curr_speed) pair.append(abs(delta_t.total_seconds())) combine.append(pair) Ts=curr_event #print combine total_n = 0 for i in range(len(combine)): total_n+=combine[i][1] prod=0 for i in range(len(combine)): curr_prod=(combine[i][0])*(combine[i][1]) prod=prod+curr_prod final_avg=prod/total_n final_avg=final_avg*0.001 print final_avg final_averages.append(final_avg) print final_averages plotly.offline.plot({ "data": [ Scatter(x=[1,2,4,6,8,10,12,14.16,18,20,22,24], y=final_averages) ], "layout": Layout( title="16-16 Server Client Architecture" ) })
dates.append(date) brightnesses.append(brightness) lats.append(row[0]) lons.append(row[1]) hover_texts.append(label) row_num += 1 if row_num == num_rows: break # Map the fires. data = [{ 'type': 'scattergeo', 'lon': lons, 'lat': lats, 'text': hover_texts, 'marker': { 'size': [brightness / 20 for brightness in brightnesses], 'color': brightnesses, 'colorscale': 'YlOrRd', 'reversescale': True, 'colorbar': {'title': 'Brightness'}, }, }] my_layout = Layout(title='Global Fire Activity') fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename='global_fires.html')
from die import Die # Create two D6 dice. die_1 = Die() die_2 = Die() # Make some rolls, and store results in a list. results = [] for roll_num in range(1000): result = die_1.roll() * die_2.roll() results.append(result) # Analyze the results. frequencies = [] max_result = die_1.num_sides * die_2.num_sides for value in range(1, max_result + 1): frequency = results.count(value) frequencies.append(frequency) # Visualize the results. x_values = list(range(1, max_result + 1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': 'Result', 'dtick': 1} y_axis_config = {'title': 'Frequency of Result'} my_layout = Layout(title='Results of multiplying two D6 dice 1000 times', xaxis=x_axis_config, yaxis=y_axis_config) offline.plot({'data': data, 'layout': my_layout}, filename='d6_d6mult.html')
from plotly import offline from die import Die # Создание кубика D6 die = Die() # Моделирование серии бросков с сохранением результатов в списке results = [] for roll_num in range(1000): result = die.roll() results.append(result) # Анализ результатов frequencies = [] for value in range(1, die.num_sides + 1): frequency = results.count(value) frequencies.append(frequency) # Визуализация результатов x_values = list(range(1, die.num_sides + 1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': 'Result'} y_axis_config = {'title': 'Frequency of Result'} my_layout = Layout(title='Results of rolling one D6 1000 times', xaxis=x_axis_config, yaxis=y_axis_config) offline.plot({'data': data, 'layout': my_layout}, filename='d6.html') print(frequencies)
lats.append(lat) lons.append(lon) if bright > bright_min: brights.append(bright) #html map plotting from plotly.graph_objs import Scattergeo, Layout from plotly import offline data = [{ "type": "scattergeo", "lon": lons, "lat": lats, "marker": { "size": [20 for bright in brights], "color": brights, "colorscale": "Viridis", "reversescale": True, "colorbar": { "title": "Brightness" }, }, }] my_layout = Layout(title=title) fig = {"data": data, "layout": my_layout} offline.plot(fig, filename="global_fires.html")
x1.append(row["date"]) y1.append( ((int(row["cases"]) - previous_total1) / population[state1]) * 100000) previous_total1 = int(row["cases"]) elif row["state"] == state2: x2.append(row["date"]) y2.append( ((int(row["cases"]) - previous_total2) / population[state2]) * 100000) previous_total2 = int(row["cases"]) elif row["state"] == state3: x3.append(row["date"]) y3.append( ((int(row["cases"]) - previous_total3) / population[state3]) * 100000) previous_total3 = int(row["cases"]) trace0 = go.Scatter(x=x1, y=y1, name=state1) trace1 = go.Scatter(x=x2, y=y2, name=state2) trace2 = go.Scatter(x=x3, y=y3, name=state3) graph = { "data": [trace0, trace1, trace2], "layout": Layout(title=( f"{state1}, {state2} and {state3} comparison daily cases per 100,000")) } plotly.offline.plot(graph, filename="statecomparison.html")
def visual(): data = pd.read_csv('log_data/NEO_270619_01_25_04.csv') data['Date'] = pd.to_datetime(data['Date']) # startDate = data.iloc[0].Date # endDate = data.iloc[-1].Date # # # start = int(datetime.timestamp(startDate)) * 1000 + (8*60*60*1000) # end = int(datetime.timestamp(endDate)) * 1000 + (8*60*60*1000) # # # end = '1561702500000' # # getData('NEOUSDT',Client.KLINE_INTERVAL_15MINUTE,start=start,end=end) # exit() klines = pd.read_csv('260619_to_280619_analysis/NEOUSDT_15m.csv') buys = {} buys['date'] = [] buys['price'] = [] buys['target'] = [] buys['exit'] = [] sells = {} sells['date'] = [] sells['price'] = [] prices = {} prices['date'] = [] prices['price'] = [] for i, r in data.iterrows(): prices['date'].append(r['Date']) prices['price'].append(r['Current Price']) if not pd.isna(r['Open Phase Exited']): buys['date'].append(r['Date']) buys['price'].append(r['Buy Price']) buys['target'].append(data.iloc[i + 1]['Target']) buys['exit'].append(data.iloc[i + 1]['Drop Threshold']) if not pd.isna(r['Mini Sell Price']): sells['date'].append(r['Date']) sells['price'].append(r['Mini Sell Price']) a = Candlestick(x=klines.DateTime, open=klines.open, high=klines.high, low=klines.low, close=klines.close) bolliDate = [] bolliLow = [] for i, r in klines.iterrows(): if i < 8: continue bolliDate.append(r.DateTime) bolliLow.append(bollingerLow(klines.iloc[i - 5:i].close)) bolliData = Scatter(name='Bolli', x=bolliDate, y=bolliLow, marker=dict(color='navy', size=4)) priceData = Scatter(name='Current Price', x=prices['date'], mode='lines', y=prices['price'], marker=dict(color='grey', size=10, symbol='star')) targetData = Scatter(name='target', x=buys['date'], y=buys['target'], mode='markers', marker=dict(symbol='triangle-up', color='blue', size=4)) # miniTargetData = Scatter(name='miniTarget',x=miniTargetDate,y=miniTargetList,mode='markers',marker=dict(symbol='triangle-up',color='pink',size=3)) # buyData = Scatter(name='Buy', mode='markers', marker=dict(symbol='circle-open-dot', color='royalblue', size=14), x=buys['date'], y=buys['price']) sellData = Scatter(name='Sell', mode='markers', marker=dict(symbol='star', color='black', size=14), x=sells['date'], y=sells['price']) # miniSellData = Scatter(name='miniSell',mode='markers', marker=dict(symbol='circle-open-dot',color='darkgreen', size=10), x=miniSellDate, y=miniSellPrice) # # buyStopData = Scatter(name='buyStop',mode='markers', marker=dict(symbol='diamond',color='black', size=7), x=buyOrderDate, y=buyOrderStop) # buyLimitData = Scatter(name='buyLimit',mode='markers', marker=dict(symbol='diamond-open',color='black', size=7), x=buyOrderDate, y=buyOrderLimit) # exitData = Scatter(name='exit', mode='markers', marker=dict(symbol='diamond', color='orange', size=7), x=buys['date'], y=buys['exit']) # sellLimitData = Scatter(name='sellLimit',mode='markers', marker=dict(symbol='diamond-open',color='orange', size=7), x=sellOrderDate, # y=sellOrderLimit) # # miniSellStopData = Scatter(name='miniSellStop',mode='markers', marker=dict(symbol='diamond',color='red', size=7), x=miniSellOrderDate, # y=miniSellOrderStop) # miniSellLimitData = Scatter(name='miniSellLimit',mode='markers', marker=dict(symbol='diamond-open',color='red', size=7), x=miniSellOrderDate, # y=miniSellOrderLimit) # # cancelData = Scatter(name='cancel',mode='markers', marker=dict(color='grey', size=7,symbol='cross'), x=cancelDate, y=cancelPrice) # majorFig = Figure(data=[ a, priceData, bolliData, targetData, buyData, exitData, sellData ], layout=Layout(xaxis=dict( rangeslider=dict(visible=False), showgrid=True, ))) print('printing graph...') plotly.offline.plot( majorFig, # show_link=False, # # output_type='div', # include_plotlyjs=False, # filename='charts//'+coin+'_'+str(seed)+'_'+ interval+ '_'+datetime.utcnow().strftime("%d%m%y_%H:%M:%S")+'.html', auto_open=True, config={ 'displaylogo': False, 'modeBarButtonsToRemove': [ 'sendDataToCloud', 'select2d', 'zoomIn2d', 'zoomOut2d', 'resetScale2d', 'hoverCompareCartesian', 'lasso2d' ], 'displayModeBar': True })
lon = eq['geometry']['coordinates'][0] lat = eq['geometry']['coordinates'][1] mags.append(mag) lons.append(lon) lats.append(lat) print('Mags') print(mags[:10]) print('Lons') print(lons[:10]) print('Lats') print(lats[:10]) from plotly.graph_objs import Scattergeo, Layout from plotly import offline ''' data = [Scattergeo(lon=lons, lat=lats)] ''' data = [{ 'type': Scattergeo, 'lon': lons, 'lat': lats, 'marker': { 'size': [5 * mag for mag in mags], }, }] my_layout = Layout(title='global earthquakes') fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename='global_earthquake.html')
from plotly import offline from die import Die # Create a D6 die_1 = Die() die_2 = Die(10) # make some rolls, and store the results in a list. results = [] for roll_num in range(50_000): result = die_1.roll() + die_2.roll() results.append(result) # Analyze the results frequencies = [] max_result = die_1.num_sides + die_2.num_sides for value in range(2, max_result + 1): frequency = results.count(value) frequencies.append(frequency) # Visualize the results. x_values = list(range(2, max_result + 1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': 'Result', 'dtick': 1} y_axis_config = {'title': 'Frequency of Result'} my_layout = Layout(title="Results of rolling two D6 and a d10 50_000 times", xaxis=x_axis_config, yaxis=y_axis_config) offline.plot({'data': data, "layout": my_layout}, filename='d6_d10.html')
y=[], name='Temp', stream=Stream(token=stream_token_temperature # Sets up temperature stream ), yaxis='y') trace_lightlevel = Scatter( x=[], y=[], name='Light %', stream=Stream(token=stream_token_lightlevel # Sets up Lightlevel stream ), yaxis='y2') layout = Layout( title='Sun Tracker - Temperature and Lightlevel Readings', #Labels graph yaxis=YAxis(title='Celcius'), yaxis2=YAxis(title='Light %', side='right', overlaying="y")) #Streams the data to plotly data = Data([trace_temperature, trace_lightlevel]) fig = Figure(data=data, layout=layout) print py.plot(fig, filename='Sun Tracker - Temperature and Lightlevel Readings') stream_temperature = py.Stream(stream_token_temperature) stream_temperature.open() stream_lightlevel = py.Stream(stream_token_lightlevel) stream_lightlevel.open()
brightnesses.append(brightness) date = datetime.strptime(row[5], '%Y-%m-%d') lat = lats.append(row[0]) lon = lons.append(row[1]) label = hover_texts.append(f"{date.strftime('%m-%d-%y')} - {brightness}") # Limit the data and stop the loop to prevent slow down. limit_data_row += 1 if limit_data_row == limit_data_rows: break # Map the fires. data = [{ 'type': 'scattergeo', 'lon': lons, 'lat': lats, 'text': hover_texts, 'marker': { 'size': [brightness/50 for brightness in brightnesses], 'color': brightnesses, 'colorscale': 'ylOrRd', 'reversescale': True, 'colorbar': {'title': 'Brightness'}, } }] my_layout = Layout(title='Global Fire Activity - 7 Days') fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename='Projects/DataVisualization/DownloadingData/CSV_Format/global_fires.html')
info.append(text) # Нанесение данных на карту data = [{ 'type': 'scattergeo', # Scattergeo позволяет определить данные на диаграмме карты мира 'lon': lons, # Долгота 'lat': lats, # Широта 'text': info, # Информация о месте землетрясерния при наведении мышью на маркер 'marker': { 'size': [mag * 5 for mag in mags ], # Увеличение точек землетрясений для ощещния разницы в их силе 'color': mags, # Сообщает Plotly какое значение должно использоваться для определения маркера на цветовой шкале 'colorscale': 'Viridis', # Какой цветовой диапозон должен использоваться 'reversescale': True, # Подобрать наиболее подходящий вариант True / False(по умолчанию) 'colorbar': { 'title': 'Magnitude' }, # Цветовой шкале рписваиватся имя для понимания значения каждого цвета }, }] filename_html = f"{all_eq_data['metadata']['title']}.html" my_layout = Layout(title='Global Earthquakes in 30 days') fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename=filename_html)
result = sum(rolls) else: result = reduce(operator.mul, rolls, 1) results.append(result) # Analyze the results. min_result = len(dice_set) if ope == 's' else 1 max_result = sum([d.num_sides for d in dice_set]) if ope == 's' else reduce( operator.mul, [d.num_sides for d in dice_set], 1) frequencies = list( [results.count(v) for v in range(min_result, max_result + 1)]) # Visualize the results. x_values = list(range(min_result, max_result + 1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': "Result", 'dtick': 1} y_axis_config = {'title': "Fequency of Result"} dice_str = ', '.join([str(d) for d in dice_set]) my_layout = Layout(title=f"Results of rolling {dice_str} {n_rolls} times", xaxis=x_axis_config, yaxis=y_axis_config) filename = dice_str = '_'.join([str(d).lower() for d in dice_set]) + f'_{n_rolls}_{ope}.html' offline.plot({ 'data': data, 'layout': my_layout }, filename=f'/mnt/f/tmp/{filename}')
def show_plot(data, title, filename='plot.html'): layout_comp = Layout(title=title) fig_comp = Figure(data=data, layout=layout_comp) plotly.offline.plot(fig_comp, filename=filename)
mags, lons, lats, hover_texts = [], [], [], [] for eq_dict in all_eq_dicts: mag = eq_dict["properties"]["mag"] lon = eq_dict["geometry"]["coordinates"][0] lat = eq_dict["geometry"]["coordinates"][1] title = eq_dict["properties"]["title"] mags.append(mag) lons.append(lon) lats.append(lat) hover_texts.append(title) data = [{ 'type': 'scattergeo', 'lon': lons, 'lat': lats, "text": hover_texts, "marker": { "size": [3 * mag for mag in mags], "color": mags, "colorscale": "Bluered", "reversescale": False, "colorbar": { "title": "Magnitude" }, }, }] plot_title = all_eq_data["metadata"]["title"] my_layout = Layout(title=plot_title) fig = {"data": data, "layout": my_layout} offline.plot(fig, filename="global_earthquakes.html")
longitude.append(longit) latitude.append(latit) print(mags[:10]) print(longitude[:10]) print(latitude[:10]) from plotly.graph_objs import Scattergeo, Layout from plotly import offline data = [ { "type": "scattergeo", "lon": longitude, "lat": latitude, "marker": { "size": [5 * mag for mag in mags], "color": mags, "colorscale": "Viridis", "reversescale": True, "colorbar": {"title": "Magnitude"}, }, } ] my_layout = Layout(title="Global Earthquakes") fig = {"data": data, "layout": my_layout} offline.plot(fig, filename="global_earthquakes.html")
for eq_dicts in all_eq_dicts: mags.append(eq_dicts['properties']['mag']) lons.append(eq_dicts['geometry']['coordinates'][0]) lats.append(eq_dicts['geometry']['coordinates'][1]) hover_text.append(eq_dicts['properties']['title']) print(mags[:10]) print(lons[:5]) print(lats[:5]) # data = [Scattergeo(lon=lons, lat=lats)] data = [{ 'type': 'scattergeo', 'lon': lons, 'lat': lats, 'text': hover_text, 'marker': { 'size': [5 * mag for mag in mags], 'color': mags, 'colorscale': 'Viridis', 'reversescale': True, 'colorbar': { 'title': 'Magnitude' } } }] my_layout = Layout(title={'text': title, 'x': 0.5}) fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename='global_earthquakes.html')
print(lats[:10]) ############################################################# from plotly.graph_objs import Scattergeo, Layout #uses world maps from plotly import offline #data = [Scattergeo(lon=lons, lat=lats)] #Scattergeo needs these as arguments, basic data layouts data = [{ 'type': 'scattergeo', 'lon': lons, 'lat': lats, 'marker': { 'size': [ 5 * mag for mag in mags ], #for each magnitude in the list of magnitudes, take that magnitude and multiply by 5 'color': mags, 'colorscale': 'Viridis', 'reversescale': True, 'colorbar': { 'title': 'Magnitude' } }, }] my_layout = Layout(title='Global Earthquakes') fig = {'data': data, 'layout': my_layout} offline.plot(fig, filename='global_earthquakes.html')
def graph_military_spending_over_time(): #Generate scatter plots for each country data = [] with open('data/SIPRI-Milex-data-1988-2015-cleaned-current-usd.csv' ) as current_usd: reader = csv.reader(current_usd) headers = next(reader, None) for row in reader: #Data unavailable, or country didn't exist at the time if ('. .' in row[13:] or 'xxx' in row[13:]): continue trace = Scatter(x=headers[13:], y=row[13:], name=row[0], fill='tonexty', line=dict(width=.5), mode='lines', textfont=dict(family='sans serif', size=30, color='#ff7f0e')) data.append(trace) #Sort scatter plots by countries with highest expenditures in 2015 data = sorted(data, key=lambda trace: float(trace.y[-1])) #Layout taken from https://plot.ly/python/figure-labels/ layout = Layout( title='Discretionary Military Spending 2000-2015', xaxis=dict(title='Year', titlefont=dict(family='Courier New, monospace', size=26, color='#7f7f7f')), yaxis=dict(title='Millions of 2015 US dollars', titlefont=dict(family='Courier New, monospace', size=26, color='#7f7f7f')), annotations=[ dict(x=2009, y=668567, xref='x', yref='y', text='Obama Takes Office; deployments in Iraq winding down', showarrow=True, arrowhead=7, ax=-120, ay=-40), dict(x=2003, y=415223, xref='x', yref='y', text='Beginning of Iraq War', showarrow=True, arrowhead=7, ax=-20, ay=-40), dict(x=2011, y=711338, xref='x', yref='y', text='Official end of Iraq War', showarrow=True, arrowhead=7, ax=0, ay=-25), dict(x=2001, y=312743, xref='x', yref='y', text='9/11; Beginning of War in Afghanistan', showarrow=True, arrowhead=7, ax=-20, ay=-40), dict(x=2014, y=609914, xref='x', yref='y', text='Official End of War in Afghanistan', showarrow=True, arrowhead=7, ax=20, ay=-40) ]) fig = Figure(data=data[len(data) - 15:], layout=layout) plot(fig, filename="images/military-spending-over-time")
import plotly as py from plotly.graph_objs import Scatter, Layout, Figure import numpy as np import pandas as pd read = pd.read_csv('DriveLog.csv') df = read[read.driveMode == 'PATH_FOLLOWING'] startPoint = read.shape[0] - df.shape[0] startTime = df.ix[startPoint, 'sysTime'] xaxis = (df['sysTime'] - startTime ) * 10E-10 #should be 10E-9 but that makes our time 10x too long????? layout = Layout(title='DriveLog.csv graph', plot_bgcolor='rgb(230, 230,230)') #,height=1500,width=1500) def data(arg): return Scatter(x=xaxis, y=df[arg], mode='lines', name=arg) #position data leftPathPos = data('leftPathPos') leftEncoder = data('leftEncoder') rightPathPos = data('rightPathPos') rightEncoder = data('rightEncoder') #velocity data leftPathVel = data('leftPathVel') leftEncoderVel = data('leftEncoderVel') rightPathVel = data('rightPathVel') rightEncoderVel = data('rightEncoderVel')
class OrbitPlotter3D(BaseOrbitPlotter): """OrbitPlotter3D class. """ def __init__(self, figure=None, dark=False): super().__init__(figure) self._layout = Layout( autosize=True, scene=dict( xaxis=dict(title="x (km)"), yaxis=dict(title="y (km)"), zaxis=dict(title="z (km)"), aspectmode="data", # Important! ), ) if dark: self._layout.template = "plotly_dark" def _plot_point(self, radius, color, name, center=[0, 0, 0] * u.km): # We use _plot_sphere here because it's not easy to specify the size of a marker # in data units instead of pixels, see # https://stackoverflow.com/q/47086547 return self._plot_sphere(radius, color, name, center) def _plot_sphere(self, radius, color, name, center=[0, 0, 0] * u.km): xx, yy, zz = generate_sphere(radius, center) sphere = Surface( x=xx.to(u.km).value, y=yy.to(u.km).value, z=zz.to(u.km).value, name=name, colorscale=[[0, color], [1, color]], cauto=False, cmin=1, cmax=1, showscale=False, ) self._figure.add_trace(sphere) return sphere def _plot_trajectory(self, trajectory, label, color, dashed): trace = Scatter3d( x=trajectory.x.to(u.km).value, y=trajectory.y.to(u.km).value, z=trajectory.z.to(u.km).value, name=label, line=dict(color=color, width=5, dash="dash" if dashed else "solid"), mode="lines", # Boilerplate ) self._figure.add_trace(trace) return trace @u.quantity_input(elev=u.rad, azim=u.rad, distance=u.km) def set_view(self, elev, azim, distance=5 * u.km): x = distance * np.cos(elev) * np.cos(azim) y = distance * np.cos(elev) * np.sin(azim) z = distance * np.sin(elev) self._layout.update( { "scene": { "camera": { "eye": { "x": x.to(u.km).value, "y": y.to(u.km).value, "z": z.to(u.km).value, } } } } ) if not self._figure._in_batch_mode: return self.show()
from plotly.graph_objs import Bar, Layout from plotly import offline from die import Die die_1 = Die() die_2 = Die() die_3 = Die() results = [] for roll_num in range(5_000_000): result = die_1.roll() + die_2.roll() + die_3.roll() results.append(result) frequencies = [] max_result = die_1.num_sides + die_2.num_sides + die_3.num_sides for value in range(3, max_result+1): frequency = results.count(value) frequencies.append(frequency) x_values = list(range(3, max_result+1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': 'Result', 'dtick': 1} y_axis_config = {'title': 'Frequency of Result'} my_layout = Layout(title='Results of rolling THREE D8s Several Times', xaxis=x_axis_config, yaxis=y_axis_config) offline.plot({'data': data, 'layout': my_layout}, filename='d8_d8_d8.html') print(frequencies)
def st_map(self, zoom=11, style='mapbox://styles/rmetfc/ck1manozn0edb1dpmvtzle2cp', build_order=None): if self.dataset.node_station_info is None or len( self.dataset.node_station_info) == 0: raise ValueError('No station information found in dataset') import numpy as np import plotly from plotly.graph_objs import Scattermapbox, Layout mapboxAccessToken = "pk.eyJ1Ijoicm1ldGZjIiwiYSI6ImNrMW02YmwxbjAxN24zam9kNGVtMm5raWIifQ.FXKqZCxsFK-dGLLNdeRJHw" # os.environ['MAPBOX_API_KEY'] = mapboxAccessToken lat_lng_name_list = [e[2:] for e in self.dataset.node_station_info] build_order = build_order or list( range(len(self.dataset.node_station_info))) color = ['rgb(255, 0, 0)' for _ in build_order] lat = np.array([float(e[2]) for e in self.dataset.node_station_info ])[self.traffic_data_index] lng = np.array([float(e[3]) for e in self.dataset.node_station_info ])[self.traffic_data_index] text = [str(e) for e in range(len(build_order))] file_name = self.dataset.dataset + '-' + self.dataset.city + '.html' bikeStations = [ Scattermapbox( lon=lng, lat=lat, text=text, mode='markers', marker=dict( size=6, # color=['rgb(%s, %s, %s)' % (255, # # 195 - e * 195 / max(build_order), # # 195 - e * 195 / max(build_order)) for e in build_order], color=color, opacity=1, )) ] layout = Layout( title= 'Bike Station Location & The latest built stations with deeper color', autosize=True, hovermode='closest', showlegend=False, mapbox=dict(accesstoken=mapboxAccessToken, bearing=0, center=dict(lat=np.median(lat), lon=np.median(lng)), pitch=0, zoom=zoom, style=style), ) fig = dict(data=bikeStations, layout=layout) plotly.offline.plot(fig, filename=file_name)
from die import Die # Create a D6 and a D10. die_1 = Die(8) die_2 = Die(8) # Numver of dice die_count = 2 # Make some rolls, and store results in a list. results = [] results = [(die_1.roll() + die_2.roll()) for roll_num in range(500_000)] print(results) # Aanlyze the results. frequencies = [] max_result = die_1.num_sides + die_2.num_sides frequencies = [results.count(value) for value in range(2, max_result+1)] print(frequencies) # Visualize the results. x_values = list(range(die_count, max_result+1)) data = [Bar(x=x_values, y=frequencies)] x_axis_config = {'title': 'Result', 'dtick': 1} y_axis_config = {'title': 'Frequency of Result'} my_layout = Layout(title='Results of rolling a D6 and a D10 dice 50000 times' , xaxis=x_axis_config, yaxis=y_axis_config) offline.plot({'data': data, 'layout': my_layout}, filename='d8_d8.html') print(frequencies)
name='', opacity = 0.75, xaxis="x") trace1 = Histogram( x=x2, name='', histnorm='probability', opacity=0.75, xaxis="x1") data = [trace0, trace1] layout = Layout(barmode='overlay', title='出度和入度分布', xaxis1={"domain": [0, 0.5], "title": "入度"}, xaxis2={"domain": [0.5, 1], "title": "出度"} ) fig = Figure(data=data, layout=layout) py.offline.iplot(fig, filename='degree_chart.html') #%% u = list(b.values()) u.count(0) #%% nx.degree_assortativity_coefficient(epinions_graph)
class OrbitPlotter3D(BaseOrbitPlotter): """OrbitPlotter3D class. """ def __init__(self, figure=None, dark=False): super().__init__(figure) self._layout = Layout( autosize=True, scene=dict( xaxis=dict(title="x (km)"), yaxis=dict(title="y (km)"), zaxis=dict(title="z (km)"), aspectmode="data", # Important! ), ) if dark: self._layout.template = "plotly_dark" def _plot_point(self, radius, color, name, center=[0, 0, 0] * u.km): # We use _plot_sphere here because it's not easy to specify the size of a marker # in data units instead of pixels, see # https://stackoverflow.com/q/47086547 return self._plot_sphere(radius, color, name, center) def _plot_sphere(self, radius, color, name, center=[0, 0, 0] * u.km): xx, yy, zz = generate_sphere(radius, center) sphere = Surface( x=xx.to(u.km).value, y=yy.to(u.km).value, z=zz.to(u.km).value, name=name, colorscale=[[0, color], [1, color]], cauto=False, cmin=1, cmax=1, showscale=False, ) self._figure.add_trace(sphere) return sphere def _plot_trajectory(self, trajectory, label, color, dashed): trace = Scatter3d( x=trajectory.x.to(u.km).value, y=trajectory.y.to(u.km).value, z=trajectory.z.to(u.km).value, name=label, line=dict(color=color, width=5, dash="dash" if dashed else "solid"), mode="lines", # Boilerplate ) self._figure.add_trace(trace) return trace @u.quantity_input(elev=u.rad, azim=u.rad, distance=u.km) def set_view(self, elev, azim, distance=5 * u.km): x = distance * np.cos(elev) * np.cos(azim) y = distance * np.cos(elev) * np.sin(azim) z = distance * np.sin(elev) self._layout.update({ "scene": { "camera": { "eye": { "x": x.to(u.km).value, "y": y.to(u.km).value, "z": z.to(u.km).value, } } } }) if not self._figure._in_batch_mode: return self.show()
start, stop = raw.time_as_index([0, 10]) n_channels = 20 data, times = raw[picks[:n_channels], start:stop] ch_names = [raw.info['ch_names'][p] for p in picks[:n_channels]] # Finally, we create the plotly graph by creating a separate subplot for each channel # In[15]: step = 1. / n_channels kwargs = dict(domain=[1 - step, 1], showticklabels=False, zeroline=False, showgrid=False) # create objects for layout and traces layout = Layout(yaxis=YAxis(kwargs), showlegend=False) traces = [Scatter(x=times, y=data.T[:, 0])] # loop over the channels for ii in range(1, n_channels): kwargs.update(domain=[1 - (ii + 1) * step, 1 - ii * step]) layout.update({'yaxis%d' % (ii + 1): YAxis(kwargs), 'showlegend': False}) traces.append(Scatter(x=times, y=data.T[:, ii], yaxis='y%d' % (ii + 1))) # add channel names using Annotations annotations = Annotations([Annotation(x=-0.06, y=0, xref='paper', yref='y%d' % (ii + 1), text=ch_name, font=Font(size=9), showarrow=False) for ii, ch_name in enumerate(ch_names)]) layout.update(annotations=annotations) # set the size of the figure and plot it