diff options
Diffstat (limited to 'BER Plots.ipynb')
| -rw-r--r-- | BER Plots.ipynb | 892 |
1 files changed, 892 insertions, 0 deletions
diff --git a/BER Plots.ipynb b/BER Plots.ipynb new file mode 100644 index 0000000..4e71d1a --- /dev/null +++ b/BER Plots.ipynb @@ -0,0 +1,892 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from math import nan, inf\n", + "data = {'dec_proto_am_ber_top.py': ([1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10.0, 12.0, 15.0, 18.0, 22.0, 27.0, 33.0, 39.0, 47.0, 56.0, 68.0, 82.0, 100.0, 120.0, 150.0, 180.0, 220.00000000000003, 270.0, 330.0, 390.0, 470.0, 560.0, 680.0, 819.9999999999999], [-1.1706362050026655, -1.193387892562896, -1.2494141100905836, -1.273546683602035, -1.3226867043413222, -1.3284842972643673, -1.4249085476621985, -2.4881654670462012, -2.9280282892286777, -1.8337596086785197, -3.4516299068927765, -3.6739503433927894, -3.85142894461751, -4.2109690103679895, -4.841764334589243, -5.121118910610676, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf, -inf], [0.000562024584446438, 0.002583366143280799, 0.003536123538459578, 0.0060136203314800725, 0.0017120634851061035, 0.01202664019209608, 0.009352711681458127, 0.010626429313400118, 0.0031605552412962345, 0.07580074150906693, 0.008303067934118849, 0.010968003992851543, 0.010921403354231309, 0.014436211616218221, 0.045257276108434545, 0.05063300417965297, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'dec_proto_am_dc_ber_top.py': ([1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10.0, 12.0, 15.0, 18.0, 22.0, 27.0, 33.0, 39.0, 47.0, 56.0, 68.0, 82.0, 100.0, 120.0, 150.0, 180.0, 220.00000000000003, 270.0, 330.0, 390.0, 470.0, 560.0, 680.0, 819.9999999999999], [-1.208226392045617, -1.2001309534534812, -1.2082590111531317, -1.2057580375112593, -1.214704089694553, -1.231758143831406, -1.2328452042170934, -1.2342556988606688, -1.2555496906861663, -1.2633800823241472, -1.2801077286712825, -1.292429564986378, -1.2502315024699062, -1.2731027859982436, -1.3264964096914462, -1.350060076963517, -1.402916835230801, -1.6361557068303227, -1.3996004345826805, -2.025891115888953, -2.2259163050377957, -2.403329889470167, -2.5532801901852644, -2.6723825335502625, -2.7451475376985512, -2.7838943274880226, -2.7973828878928355, -2.8114503007382154, -2.7500487601808214, -2.7576294792325875, -2.7531131004032336, -2.771351588479543, -2.763352069271704, -2.7856492625232554, -2.8089246354122395, -2.805404500961304], [0.0006223969511333752, 0.001109700896962153, 0.00210398864758181, 0.0009171589283670842, 0.01005799259051457, 0.01198940071540007, 0.013730311872618627, 0.020358273695306007, 0.019376830251761356, 0.02698367824924875, 0.03015560422449139, 0.04189253434399468, 0.04626542022859063, 0.07217384274518368, 0.08584595043975161, 0.12539079396237413, 0.09791907379447246, 0.10581626829587948, 0.18250650933422224, 0.07591527055792387, 0.20120497031325296, 0.2529568393261202, 0.3140587593946733, 0.3626712973758648, 0.39454531783086805, 0.40694947364033235, 0.4101018950589088, 0.38136874448954844, 0.4108311426740005, 0.40839715897167816, 0.4083367927775933, 0.40823628264400785, 0.4080951641200549, 0.40959607776701595, 0.40969886669408834, 0.4099477409126599]), 'dec_proto_fm_ber_top.py': ([1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10.0, 12.0, 15.0, 18.0, 22.0, 27.0, 33.0, 39.0, 47.0, 56.0, 68.0, 82.0, 100.0, 120.0, 150.0, 180.0, 220.00000000000003, 270.0, 330.0, 390.0, 470.0, 560.0, 680.0, 819.9999999999999], [-1.3057961403392255, -1.3484294968657196, -1.4667961434461176, -2.8690875116735697, -1.6547222812660038, -1.3891625558026135, -3.5982019547373056, -3.771391890011728, -4.029223203659058, -4.187133187428117, -4.5257152915000916, -4.8291374538093805, -4.9882102105766535, -4.988903861492872, -4.977243402972817, -4.991583617404103, -4.978662932291627, -4.995597720146179, -4.980234434828162, -4.898328188806772, -4.886065758764744, -4.892892232164741, -4.887955756857991, -4.894121825695038, -4.874834077432752, -4.881909834221005, -4.885749246925116, -4.879474958404899, -4.893610496073961, -4.893589161336422, -4.900892127305269, -4.89244575984776, -4.886744260787964, -4.895636919885874, -4.909515650942922, -4.8994301706552505], [0.014213245118859085, 0.001330722343276248, 0.013951488821076687, 0.0041134580502828425, 0.038365233682153145, 0.030733212747131068, 0.0091992661239188, 0.010529797577944408, 0.014647350039240111, 0.014036738695564741, 0.0201667482688038, 0.03195929762792339, 0.050554225347760565, 0.05155121488079693, 0.05696637316379902, 0.05194819962648275, 0.04815391425232906, 0.04198674248536032, 0.0531488148233794, 0.043095657257340825, 0.05140641385191975, 0.047935496094956176, 0.05329373773860191, 0.05040869503181174, 0.05644083328947176, 0.053389328604204575, 0.05074839526504205, 0.053625197798602975, 0.047252304573416753, 0.051310379811370974, 0.046438087027853785, 0.05365724267638675, 0.0534321058650641, 0.04956836848859283, 0.04218369035098332, 0.05032427561533336])}" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "labels = {'dec_proto_am_ber_top.py': 'ASK',\n", + " 'dec_proto_am_dc_ber_top.py': '\"DC\"',\n", + " 'dec_proto_fm_ber_top.py': 'FSK'}" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'BER [dB]')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 5))\n", + "ax.set_title('BERs for basic modulation types')\n", + "for sim, (ampls, bers, stdevs) in data.items():\n", + " # The Gnuradio BER block calculates bit error rate over whole bytes, but we only feed in bits casted\n", + " # to bytes. We correct for this by adding log10(8).\n", + " bers = [(x + math.log10(8))*10 for x in bers]\n", + " ax.errorbar(ampls, bers, yerr=stdevs, label=labels[sim])\n", + "ax.grid()\n", + "ax.legend()\n", + "ax.set_xscale('log')\n", + "ax.set_xlabel('Amplitude Δf [mHz]')\n", + "ax.set_ylabel('BER [dB]')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |