pyFAI/sandbox/Simple_peak_picker.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib nbagg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"PYOPENCL_COMPILER_OUTPUT\"]=\"1\"\n",
    "import numpy\n",
    "import fabio\n",
    "import pyopencl\n",
    "from pyopencl import array as cla\n",
    "from matplotlib.pyplot import subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose platform:\n",
      "[0] <pyopencl.Platform 'Portable Computing Language' at 0x7fd9084e5020>\n",
      "[1] <pyopencl.Platform 'NVIDIA CUDA' at 0x2f41c40>\n",
      "[2] <pyopencl.Platform 'Intel(R) OpenCL' at 0x2e338d0>\n",
      "Choice [0]:1\n",
      "Choose device(s):\n",
      "[0] <pyopencl.Device 'GeForce GTX TITAN' on 'NVIDIA CUDA' at 0x2f4d510>\n",
      "[1] <pyopencl.Device 'Quadro M2000' on 'NVIDIA CUDA' at 0x2f41bb0>\n",
      "Choice, comma-separated [0]:0\n",
      "Set the environment variable PYOPENCL_CTX='1:0' to avoid being asked again.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<pyopencl.Context at 0x2f0b0e0 on <pyopencl.Device 'GeForce GTX TITAN' on 'NVIDIA CUDA' at 0x2f4d510>>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ctx = pyopencl.create_some_context(interactive=True)\n",
    "queue = pyopencl.CommandQueue(ctx, properties=pyopencl.command_queue_properties.PROFILING_ENABLE)\n",
    "ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = fabio.open(\"/users/kieffer/workspace-400/tmp/pyFAI/test/testimages/Pilatus6M.cbf\").data\n",
    "mask = (image<0).astype(\"int8\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd92b855630>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig, ax = subplots()\n",
    "ax.imshow(image.clip(0,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext pyopencl.ipython_ext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cl_kernel\n",
    "\n",
    "//read withou caching\n",
    "float inline read_simple(global int *img, \n",
    "                     int height,\n",
    "                     int width,\n",
    "                     int row,\n",
    "                     int col){\n",
    "    //This kernel reads the value and returns it without active caching\n",
    "    float value = NAN;\n",
    "    \n",
    "    // Read\n",
    "    if ((col>=0) && (col<width) && (row>=0) && (row<height)){\n",
    "        int read_pos = col + row*width;\n",
    "        value = (float)img[read_pos];\n",
    "        if (value<0){\n",
    "            value = NAN;\n",
    "        }\n",
    "    }\n",
    "    return value;\n",
    "}\n",
    "\n",
    "\n",
    "void inline read_and_store(global int *img, \n",
    "                     int height,\n",
    "                     int width,\n",
    "                     int row,\n",
    "                     int col,\n",
    "                     int half_wind_height,\n",
    "                     int half_wind_width,\n",
    "                     local float* storage){\n",
    "    //This kernel reads the value and stores in the local storage\n",
    "    int line_size, write_pos, idx_line;\n",
    "    float value = NAN;\n",
    "    \n",
    "    // Read\n",
    "    if ((col>=0) && (col<width) && (row>0) && (row<height)){\n",
    "        int read_pos = col + row*width;\n",
    "        value = (float)img[read_pos];\n",
    "        if (value<0){\n",
    "            value = NAN;\n",
    "        }\n",
    "    }\n",
    "    // Save locally\n",
    "    if ((col>=-half_wind_width) && (col<=width+half_wind_width) && (row>-half_wind_height) && (row<=height+half_wind_height)){\n",
    "        line_size = get_local_size(0) + 2 * half_wind_width;\n",
    "        idx_line = (half_wind_height+row)%(2*half_wind_height+1);\n",
    "        write_pos = line_size*idx_line + half_wind_width + col - get_group_id(0)*get_local_size(0);\n",
    "        storage[write_pos] = value;\n",
    "    }\n",
    "    //return value\n",
    "}\n",
    "\n",
    "//Store a complete line\n",
    "void inline store_line(global int *img, \n",
    "                       int height,\n",
    "                       int width,\n",
    "                       int row,\n",
    "                       int half_wind_height,\n",
    "                       int half_wind_width,\n",
    "                       local float* storage){\n",
    "        read_and_store(img, height, width, \n",
    "                       row, get_global_id(0), \n",
    "                       half_wind_height, half_wind_width, storage);\n",
    "        if (get_local_id(0)<half_wind_width){\n",
    "            // read_and_store_left\n",
    "            read_and_store(img, height, width, \n",
    "                           row, get_group_id(0)*get_local_size(0)-half_wind_width+get_local_id(0), \n",
    "                           half_wind_height, half_wind_width, storage);\n",
    "            //read_and_store_right\n",
    "            read_and_store(img, height, width, \n",
    "                           row, (get_group_id(0)+1)*get_local_size(0)+get_local_id(0), \n",
    "                           half_wind_height, half_wind_width, storage);            \n",
    "        }\n",
    "}\n",
    "\n",
    "float read_back( int height,\n",
    "                 int width,\n",
    "                 int row,\n",
    "                 int col,\n",
    "                 int half_wind_height,\n",
    "                 int half_wind_width,\n",
    "                 local float* storage){\n",
    "    float value=NAN;\n",
    "    int write_pos, line_size, idx_line;\n",
    "    if ((col>=-half_wind_width) && (col<=width+half_wind_width) && (row>-half_wind_height) && (row<=height+half_wind_height)){\n",
    "        line_size = get_local_size(0) + 2 * half_wind_width;\n",
    "        idx_line = (half_wind_height+row)%(2*half_wind_height+1);\n",
    "        write_pos = line_size*idx_line + half_wind_width + col - get_group_id(0)*get_local_size(0);\n",
    "        value = storage[write_pos];   \n",
    "    }\n",
    "    return value;\n",
    "}\n",
    "\n",
    "// workgroup size of kernel: 32 to 128, cache_read needs to be (wg+2*half_wind_width)*(2*half_wind_height+1)*sizeof(float)\n",
    "kernel void spot_finder(global int *img, \n",
    "                               int height,\n",
    "                               int width,\n",
    "                               int half_wind_height,\n",
    "                               int half_wind_width,\n",
    "                               float threshold,\n",
    "                               float radius,\n",
    "                        global int *cnt_high, //output\n",
    "                        global int *high,     //output\n",
    "                               int high_size,\n",
    "                        local  float *cache_read,\n",
    "                        local  int *local_high,\n",
    "                               int local_size){\n",
    "    //decaration of variables\n",
    "    int col, row, cnt, i, j, where;\n",
    "    float value, sum, std, centroid_r, centroid_c, dist, mean;\n",
    "    col = get_global_id(0);\n",
    "    \n",
    "    local int local_cnt_high[1];\n",
    "    local_cnt_high[0] = 0;\n",
    "    for (i=0; i<local_size; i+=get_local_size(0)){\n",
    "        local_high[i+get_local_id(0)] = 0;\n",
    "    }\n",
    "        \n",
    "    row=0;\n",
    "    \n",
    "    //pre-load data for the first line\n",
    "    for (i=-half_wind_height; i<half_wind_height; i++){\n",
    "        store_line(img, height, width, row+i, half_wind_height, half_wind_width, cache_read);\n",
    "    }\n",
    "    barrier(CLK_LOCAL_MEM_FENCE);\n",
    "    //loop within a column\n",
    "    for (row=0;row<height; row++){\n",
    "        //read data\n",
    "        store_line(img, height, width, row+half_wind_height, half_wind_height, half_wind_width, cache_read);\n",
    "        barrier(CLK_LOCAL_MEM_FENCE);\n",
    "        //calculate mean\n",
    "        sum = 0.0f;\n",
    "        centroid_r = 0.0f;\n",
    "        centroid_c = 0.0f;\n",
    "        cnt = 0;\n",
    "        for (i=-half_wind_height; i<=half_wind_height; i++){\n",
    "            for (j=-half_wind_width; j<=half_wind_width; j++){\n",
    "                value = read_back(height, width, row+i, col+j, half_wind_height, half_wind_width, cache_read);\n",
    "                if (isfinite(value)){\n",
    "                    sum += value;\n",
    "                    centroid_r += value*i; \n",
    "                    centroid_c += value*j;\n",
    "                    cnt += 1;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "        if (cnt){\n",
    "            mean = sum/cnt;\n",
    "            dist = sum*radius;\n",
    "            if ((fabs(centroid_r)<dist) && (fabs(centroid_c)<dist)){\n",
    "                // calculate std\n",
    "                sum = 0.0;\n",
    "                for (i=-half_wind_height; i<=half_wind_height; i++){\n",
    "                    for (j=-half_wind_width; j<=half_wind_width; j++){\n",
    "                        value = read_back(height, width, row+i, col+j, half_wind_height, half_wind_width, cache_read);\n",
    "                        if (isfinite(value)){\n",
    "                            sum += pown(mean-value,2);\n",
    "                        }\n",
    "                    }\n",
    "                }\n",
    "                std = sqrt(sum/cnt);\n",
    "                value = read_back(height, width, row, col, half_wind_height, half_wind_width, cache_read);\n",
    "                if ((value-mean)>threshold*std){\n",
    "                    where = atomic_inc(local_cnt_high);\n",
    "                    if (where<local_size){\n",
    "                        local_high[where] = col+width*row;\n",
    "                    }\n",
    "                } // if intense signal\n",
    "            } // if properly centered\n",
    "        } // if patch not empty            \n",
    "        barrier(CLK_LOCAL_MEM_FENCE);\n",
    "    } //for row      \n",
    "    \n",
    "    //Store the results in global memory\n",
    "    barrier(CLK_LOCAL_MEM_FENCE);\n",
    "    if (get_local_id(0) == 0) {\n",
    "        cnt = local_cnt_high[0];\n",
    "        if ((cnt>0) && (cnt<local_size)) {\n",
    "            where = atomic_add(cnt_high, cnt);\n",
    "            if (where+cnt>high_size){\n",
    "                cnt = high_size-where; //store what we can\n",
    "            }\n",
    "            for (i=0; i<cnt; i++){\n",
    "                high[where+i] = local_high[i];\n",
    "            }\n",
    "        }\n",
    "    }//store results\n",
    "} //kernel\n",
    "\n",
    "// workgroup size of kernel: without cacheing read\n",
    "kernel void simple_spot_finder(global int *img, \n",
    "                               int height,\n",
    "                               int width,\n",
    "                               int half_wind_height,\n",
    "                               int half_wind_width,\n",
    "                               float threshold,\n",
    "                               float radius,\n",
    "                        global int *cnt_high, //output\n",
    "                        global int *high,     //output\n",
    "                               int high_size,\n",
    "                        local  int *local_high,\n",
    "                               int local_size){\n",
    "    //decaration of variables\n",
    "    int col, row, cnt, i, j, where, tid, blocksize;\n",
    "    float value, sum, std, centroid_r, centroid_c, dist, mean, M2, delta, delta2, target_value;\n",
    "    col = get_global_id(0);\n",
    "    row = get_global_id(1);\n",
    "    \n",
    "    //Initialization of output array in shared\n",
    "    local int local_cnt_high[2];\n",
    "    blocksize = get_local_size(0) * get_local_size(1);\n",
    "    tid = get_local_id(0) + get_local_id(1) * get_local_size(0);\n",
    "    if (tid < 2){\n",
    "        local_cnt_high[tid] = 0;\n",
    "    }\n",
    "        \n",
    "    for (i=0; i<local_size; i+=blocksize){\n",
    "        if ((i+tid)<local_size)\n",
    "            local_high[i+tid] = 0;\n",
    "    }\n",
    "    barrier(CLK_LOCAL_MEM_FENCE);        \n",
    "    \n",
    "    \n",
    "    //Calculate mean + std + centroids\n",
    "    mean = 0.0f;\n",
    "    M2 = 0.0f;\n",
    "    centroid_r = 0.0f;\n",
    "    centroid_c = 0.0f;\n",
    "    cnt = 0;\n",
    "    \n",
    "    for (i=-half_wind_height; i<=half_wind_height; i++){\n",
    "        for (j=-half_wind_width; j<=half_wind_width; j++){\n",
    "            value = read_simple(img, height, width, row+i, col+j);\n",
    "            if (isfinite(value)){\n",
    "                centroid_r += value*i; \n",
    "                centroid_c += value*j;\n",
    "                cnt += 1;\n",
    "                delta = value - mean;\n",
    "                mean += delta / cnt;\n",
    "                delta2 = value - mean;\n",
    "                M2 += delta * delta2;\n",
    "            }                \n",
    "        }\n",
    "    }\n",
    "    if (cnt){\n",
    "        dist = mean*radius*cnt;\n",
    "        std = sqrt(M2 / cnt);\n",
    "        target_value = read_simple(img, height, width, row, col);\n",
    "        if (((target_value-mean)>threshold*std) && (fabs(centroid_r)<dist) && (fabs(centroid_c)<dist)){\n",
    "                where = atomic_inc(local_cnt_high);\n",
    "                if (where<local_size){\n",
    "                    local_high[where] = col+width*row;\n",
    "                }\n",
    "        } // if intense signal properly centered\n",
    "    } // if patch not empty            \n",
    "    \n",
    "    //Store the results in global memory\n",
    "    barrier(CLK_LOCAL_MEM_FENCE);\n",
    "    if (tid==0) {\n",
    "        cnt = local_cnt_high[0];\n",
    "        if ((cnt>0) && (cnt<local_size)) {\n",
    "            where = atomic_add(cnt_high, cnt);\n",
    "            if (where+cnt>high_size){\n",
    "                cnt = high_size-where; //store what we can\n",
    "            }\n",
    "            local_cnt_high[0] = cnt;\n",
    "            local_cnt_high[1] = where;\n",
    "        }\n",
    "    }\n",
    "    barrier(CLK_LOCAL_MEM_FENCE);\n",
    "    //copy the data from local to global memory\n",
    "    for (i=0; i<local_cnt_high[0]; i+=blocksize){\n",
    "        high[local_cnt_high[1]+i+tid] = local_high[i+tid];\n",
    "    }//store results\n",
    "} //kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found 234 peaks in 275.350ms\n",
      "CPU times: user 233 ms, sys: 51.7 ms, total: 285 ms\n",
      "Wall time: 282 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fd92b8662b0>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def peak_count(img,\n",
    "               window=3,\n",
    "               threshold=3.0,\n",
    "               radius=1.0,\n",
    "               workgroup=32,\n",
    "               array_size=10000):\n",
    "    img_d = cla.to_device(queue, image)\n",
    "    high_d = cla.zeros(queue, (array_size,), dtype=numpy.int32)\n",
    "    high_cnt_d = cla.zeros(queue, (1,), dtype=numpy.int32)\n",
    "    read_cache = pyopencl.LocalMemory(4*(workgroup+2*window)*(2*window+1))\n",
    "    write_cache = pyopencl.LocalMemory(4096)\n",
    "    height, width = img.shape\n",
    "    size = (width+workgroup-1)&~(workgroup-1)\n",
    "    ev = spot_finder(queue, (size,), (workgroup,),\n",
    "                    img_d.data, \n",
    "                    numpy.int32(height),\n",
    "                    numpy.int32(width),\n",
    "                    numpy.int32(window),\n",
    "                    numpy.int32(window),\n",
    "                    numpy.float32( threshold),\n",
    "                    numpy.float32( radius),\n",
    "                    high_cnt_d.data,\n",
    "                    high_d.data,\n",
    "                    numpy.int32(array_size),\n",
    "                    read_cache,\n",
    "                    write_cache,\n",
    "                    numpy.int32(1024))\n",
    "    size = high_cnt_d.get()[0]     \n",
    "    print(\"found %i peaks in %.3fms\"%(size, (ev.profile.end-ev.profile.start)*1e-6))\n",
    "    return high_d.get()[:size]\n",
    "%time raw = peak_count(image, window=5, threshold=6)\n",
    "x=raw%image.shape[-1]\n",
    "y=raw//image.shape[-1]\n",
    "ax.plot(x,y,\".w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found 235 peaks in 21.018ms\n",
      "CPU times: user 25.3 ms, sys: 4.65 ms, total: 29.9 ms\n",
      "Wall time: 27.9 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fd928ccddd8>]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def simple_peak_count(img,\n",
    "               window=3,\n",
    "               threshold=3.0,\n",
    "               radius=1.0,\n",
    "               workgroup=32,\n",
    "               array_size=10000):\n",
    "    img_d = cla.to_device(queue, image)\n",
    "    high_d = cla.zeros(queue, (array_size,), dtype=numpy.int32)\n",
    "    high_cnt_d = cla.zeros(queue, (1,), dtype=numpy.int32)\n",
    "    #read_cache = pyopencl.LocalMemory(4*(workgroup+2*window)*(2*window+1))\n",
    "    write_cache = pyopencl.LocalMemory(4096)\n",
    "    height, width = img.shape\n",
    "    size_w = (width+workgroup-1)&~(workgroup-1)\n",
    "    size_h = (height+workgroup-1)&~(workgroup-1)\n",
    "    ev = simple_spot_finder(queue, (size_w,size_h), (workgroup, workgroup),\n",
    "                    img_d.data, \n",
    "                    numpy.int32(height),\n",
    "                    numpy.int32(width),\n",
    "                    numpy.int32(window),\n",
    "                    numpy.int32(window),\n",
    "                    numpy.float32( threshold),\n",
    "                    numpy.float32( radius),\n",
    "                    high_cnt_d.data,\n",
    "                    high_d.data,\n",
    "                    numpy.int32(array_size),\n",
    "                    #read_cache,\n",
    "                    write_cache,\n",
    "                    numpy.int32(1024))\n",
    "    size = high_cnt_d.get()[0]     \n",
    "    print(\"found %i peaks in %.3fms\"%(size, (ev.profile.end-ev.profile.start)*1e-6))\n",
    "    return high_d.get()[:size]\n",
    "%time raw = simple_peak_count(image, window=5, threshold=6)\n",
    "x=raw%image.shape[-1]\n",
    "y=raw//image.shape[-1]\n",
    "ax.plot(x,y,\".y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Work on scan\n",
    "from math import log2\n",
    "n = 32\n",
    "ary = numpy.ones(n)\n",
    "ary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 2\n",
      "2 4\n",
      "3 8\n",
      "4 16\n",
      "[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15. 16. 17. 18.\n",
      " 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32.]\n"
     ]
    }
   ],
   "source": [
    "ary1 = numpy.copy(ary)\n",
    "ary2 = numpy.empty_like(ary)\n",
    "\n",
    "for i in range(int(log2(n))):\n",
    "    start = 1<<i\n",
    "    print(i,start)\n",
    "    for j in range(start):\n",
    "        ary2[j] = ary1[j]\n",
    "    for j in range(start, n):\n",
    "        ary2[j] = ary1[j] + ary1[j-start]\n",
    "    ary1, ary2 = ary2, ary1\n",
    "print(ary1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.,   0.,   1.,   2.,   5.,   8.,  13.,  18.,  27.,  36.,  49.,\n",
       "        62.,  81., 100., 125., 150.])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary-numpy.ones(n).cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8512"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(32+6)*7*4*2*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}