Testing vectorized GEOS functions

shapely vectorized GEOS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing vectorized GEOS functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import shapely\n",
    "from shapely.geometry import Point, Polygon\n",
    "from shapely.geometry.base import geom_factory\n",
    "from shapely.vectorized.vectorfuncs import VectorizedImplementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "impl_vec = VectorizedImplementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "vhasz = impl_vec['has_z']\n",
    "vcontains = impl_vec['contains']\n",
    "vdistance = impl_vec['distance']\n",
    "varea = impl_vec['area']\n",
    "vcentroid = impl_vec['centroid']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<shapely.geometry.point.Point object at 0x7f99681a1160>,\n",
       "       <shapely.geometry.point.Point object at 0x7f99681a1198>,\n",
       "       <shapely.geometry.point.Point object at 0x7f99681a11d0>, ...,\n",
       "       <shapely.geometry.point.Point object at 0x7f99679afe48>,\n",
       "       <shapely.geometry.point.Point object at 0x7f99679afe80>,\n",
       "       <shapely.geometry.point.Point object at 0x7f99679afeb8>], dtype=object)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([Point(i, i) for i in range(10000)], dtype=object)\n",
    "p = Polygon([(10,10), (10,100), (100,100), (100, 10)])\n",
    "ps = np.array([ Polygon([(10,10), (10,100), (i,i), (100, 10)]) for i in range(20,100) ])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### has_z (unary predicate function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False], dtype=bool)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_hasz = vhasz(a)\n",
    "res_hasz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.1 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vhasz(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vhasz0(ps):\n",
    "    return [ p.has_z for p in ps ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.1 ms ± 498 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vhasz0(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### contains (binary predicate function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False], dtype=bool)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_contains = vcontains(p, a)\n",
    "res_contains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.9 ms ± 190 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vcontains(p, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vcontains0(poly, ps):\n",
    "    return [ poly.contains(p) for p in ps ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66.6 ms ± 850 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vcontains0(p, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### centroid (unary topological function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array('d', [28.333333333333332]), array('d', [28.333333333333332]))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_cent = vcentroid(ps)\n",
    "centroid0 = geom_factory(int(res_cent[0]))\n",
    "centroid0.xy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "235 µs ± 5.95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vcentroid(ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vcentroid0(ps):\n",
    "    # this weird-looking function avoids the overhead of calling geom_factory\n",
    "    # (which constructs the shapely object) so the two centroid functions can\n",
    "    # be directly compared\n",
    "    return [ p.impl['centroid'](p) for p in ps ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "352 µs ± 5.95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vcentroid0(ps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### area (unary real function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  900.,   990.,  1080.,  1170.,  1260.,  1350.,  1440.,  1530.,\n",
       "        1620.,  1710.,  1800.,  1890.,  1980.,  2070.,  2160.,  2250.,\n",
       "        2340.,  2430.,  2520.,  2610.,  2700.,  2790.,  2880.,  2970.,\n",
       "        3060.,  3150.,  3240.,  3330.,  3420.,  3510.,  3600.,  3690.,\n",
       "        3780.,  3870.,  3960.,  4050.,  4140.,  4230.,  4320.,  4410.,\n",
       "        4500.,  4590.,  4680.,  4770.,  4860.,  4950.,  5040.,  5130.,\n",
       "        5220.,  5310.,  5400.,  5490.,  5580.,  5670.,  5760.,  5850.,\n",
       "        5940.,  6030.,  6120.,  6210.,  6300.,  6390.,  6480.,  6570.,\n",
       "        6660.,  6750.,  6840.,  6930.,  7020.,  7110.,  7200.,  7290.,\n",
       "        7380.,  7470.,  7560.,  7650.,  7740.,  7830.,  7920.,  8010.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_area = varea(ps)\n",
    "res_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "165 µs ± 2.66 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit varea(ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def varea0(ps):\n",
    "    return [ p.area for p in ps ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "322 µs ± 6.12 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit varea0(ps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### distance (binary real function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.41421356e+01,   1.27279221e+01,   1.13137085e+01, ...,\n",
       "         1.39964716e+04,   1.39978858e+04,   1.39993001e+04])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_dist = vdistance(p, a)\n",
    "res_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52.8 ms ± 890 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vdistance(p, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vdistance0(poly, ps):\n",
    "    return [ poly.distance(p) for p in ps ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "114 ms ± 660 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vdistance0(p, a)"
   ]
  }
 ],
 "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": 2
}