cir_avg_timing_skbeam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from skbeam.core import utils\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def circular_average1(image, calibrated_center, threshold=0, nx=100,\n",
    "                     pixel_size=(1, 1),  min_x=None, max_x=None, mask=None):\n",
    "    \"\"\"Circular average of the the image data\n",
    "    The circular average is also known as the radial integration\n",
    "    Parameters\n",
    "    ----------\n",
    "    image : array\n",
    "        Image to compute the average as a function of radius\n",
    "    calibrated_center : tuple\n",
    "        The center of the image in pixel units\n",
    "        argument order should be (row, col)\n",
    "    threshold : int, optional\n",
    "        Ignore counts below `threshold`\n",
    "        default is zero\n",
    "    nx : int, optional\n",
    "        number of bins in x\n",
    "        defaults is 100 bins\n",
    "    pixel_size : tuple, optional\n",
    "        The size of a pixel (in a real unit, like mm).\n",
    "        argument order should be (pixel_height, pixel_width)\n",
    "        default is (1, 1)\n",
    "    min_x : float, optional number of pixels\n",
    "        Left edge of first bin defaults to minimum value of x\n",
    "    max_x : float, optional number of pixels\n",
    "        Right edge of last bin defaults to maximum value of x\n",
    "    mask : mask for 2D data. Assumes 1 is non masked and 0 masked.\n",
    "        None defaults to no mask.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    bin_centers : array\n",
    "        The center of each bin in R. shape is (nx, )\n",
    "    ring_averages : array\n",
    "        Radial average of the image. shape is (nx, ).\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    bad_to_nan_gen : Create a mask with np.nan entries\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    \"\"\"\n",
    "    radial_val = utils.radial_grid(calibrated_center, image.shape, pixel_size)\n",
    "\n",
    "    if mask is not None:\n",
    "        w = np.where(mask == 1)\n",
    "        radial_val = radial_val[w]\n",
    "        image = image[w]\n",
    "    bin_edges, sums, counts = utils.bin_1D(np.ravel(radial_val),\n",
    "                                           np.ravel(image), nx,\n",
    "                                           min_x=min_x,\n",
    "                                           max_x=max_x)\n",
    "    th_mask = counts > threshold\n",
    "    ring_averages = sums[th_mask] / counts[th_mask]\n",
    "\n",
    "    bin_centers = utils.bin_edges_to_centers(bin_edges)[th_mask]\n",
    "\n",
    "    return bin_centers, ring_averages \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def circular_average2(image, calibrated_center, threshold=0, nx=100,\n",
    "                     pixel_size=(1, 1),  min_x=None, max_x=None, mask=None):\n",
    "    \"\"\"Circular average of the the image data\n",
    "    The circular average is also known as the radial integration\n",
    "    Parameters\n",
    "    ----------\n",
    "    image : array\n",
    "        Image to compute the average as a function of radius\n",
    "    calibrated_center : tuple\n",
    "        The center of the image in pixel units\n",
    "        argument order should be (row, col)\n",
    "    threshold : int, optional\n",
    "        Ignore counts below `threshold`\n",
    "        default is zero\n",
    "    nx : int, optional\n",
    "        number of bins in x\n",
    "        defaults is 100 bins\n",
    "    pixel_size : tuple, optional\n",
    "        The size of a pixel (in a real unit, like mm).\n",
    "        argument order should be (pixel_height, pixel_width)\n",
    "        default is (1, 1)\n",
    "    min_x : float, optional number of pixels\n",
    "        Left edge of first bin defaults to minimum value of x\n",
    "    max_x : float, optional number of pixels\n",
    "        Right edge of last bin defaults to maximum value of x\n",
    "    mask : mask for 2D data. Assumes 1 is non masked and 0 masked.\n",
    "        None defaults to no mask.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    bin_centers : array\n",
    "        The center of each bin in R. shape is (nx, )\n",
    "    ring_averages : array\n",
    "        Radial average of the image. shape is (nx, ).\n",
    "\n",
    "    See Also\n",
    "    --------\n",
    "    bad_to_nan_gen : Create a mask with np.nan entries\n",
    "\n",
    "    Notes\n",
    "    -----\n",
    "    \"\"\"\n",
    "    radial_val = utils.radial_grid(calibrated_center, image.shape, pixel_size)\n",
    "\n",
    "    if mask is None:\n",
    "        mask = np.ones(image.shape,dtype=bool)\n",
    "    else:\n",
    "        mask = mask.astype(bool) #ensure it's the right type\n",
    "\n",
    "    radial_val = radial_val[mask]\n",
    "    image = image[mask]\n",
    "\n",
    "    bin_edges, sums, counts = utils.bin_1D(radial_val,\n",
    "                                           image, nx,\n",
    "                                           min_x=min_x,\n",
    "                                           max_x=max_x)\n",
    "    th_mask = counts > threshold\n",
    "    ring_averages = sums[th_mask] / counts[th_mask]\n",
    "\n",
    "    bin_centers = utils.bin_edges_to_centers(bin_edges)[th_mask]\n",
    "\n",
    "    return bin_centers, ring_averages \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# setup\n",
    "N = 1000\n",
    "r0 = N/2, N/2\n",
    "img = np.random.random((N,N))\n",
    "mask = np.random.random((N,N)) > .5\n",
    "Nrepeats = 10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing first\n",
      "timing second\n",
      "Time circavg1: 166.363263130188ms\n",
      "Time circavg2: 147.6438283920288ms\n"
     ]
    }
   ],
   "source": [
    "print(\"timing first\")\n",
    "from time import time as ttime\n",
    "t0_i = ttime()\n",
    "\n",
    "for i in range(Nrepeats):\n",
    "    bcens, ravgs = circular_average1(img, r0, mask=mask,min_x=10, max_x = 1400, nx=1300)\n",
    "t0_f = ttime()\n",
    "\n",
    "print(\"timing second\")\n",
    "t1_i = ttime()\n",
    "for i in range(Nrepeats):\n",
    "    bcens, ravgs = circular_average2(img, r0, mask=mask,min_x=10, max_x = 1400, nx=1300)\n",
    "t1_f = ttime()\n",
    "\n",
    "dt0 = (t0_f-t0_i)/Nrepeats\n",
    "dt1 = (t1_f-t1_i)/Nrepeats\n",
    "\n",
    "print(\"Time circavg1: {}ms\".format(dt0*1e3))\n",
    "print(\"Time circavg2: {}ms\".format(dt1*1e3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}