{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import timeit\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filt_arr = np.array([[1, 0, 0], [0, 0, 0], [0, 0, 0]])\n",
    "\n",
    "def filter_scipy(xgg):\n",
    "    return scipy.ndimage.correlate(xgg, filt_arr, mode='constant')\n",
    "\n",
    "def filter_opencv(xgg):\n",
    "    return cv2.filter2D(xgg, -1, filt_arr, borderType=cv2.BORDER_CONSTANT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_xgg = 5*np.random.rand(14, 12)-2\n",
    "\n",
    "res_scipy = filter_scipy(test_xgg)\n",
    "res_opencv = filter_opencv(test_xgg)\n",
    "\n",
    "f, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
    "ax[0].imshow(res_scipy, cmap='gray')\n",
    "ax[1].imshow(res_opencv, cmap='gray')\n",
    "ax[2].imshow(res_scipy - res_opencv, cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original function time: 0.017779 ms per call\n",
      "Original function time: 0.005683 ms per call\n"
     ]
    }
   ],
   "source": [
    "n_test_inputs = 1000\n",
    "n_repeats = 10\n",
    "\n",
    "test_inputs = [5*np.random.rand(14, 12)-2 for _ in range(n_test_inputs)]\n",
    "\n",
    "def run(method=\"original\"):\n",
    "    if method == \"original\":\n",
    "        for xgg in test_inputs:\n",
    "            filter_scipy(xgg)\n",
    "    elif method == \"opencv\":\n",
    "        for xgg in test_inputs:\n",
    "            filter_opencv(xgg)\n",
    "\n",
    "# Time the original function\n",
    "time_original = timeit.timeit(lambda: run(method=\"original\"), number=n_repeats)\n",
    "print(f\"Original function time: {1000*time_original / (n_test_inputs*n_repeats):.6f} ms per call\")\n",
    "\n",
    "time_new = timeit.timeit(lambda: run(method=\"opencv\"), number=n_repeats)\n",
    "print(f\"Original function time: {1000*time_new / (n_test_inputs*n_repeats):.6f} ms per call\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Builtin time: 0.000916 ms per call\n",
      "Numpy time: 0.001948 ms per call\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "n_repeats = 100000\n",
    "\n",
    "time_builtin = timeit.timeit(lambda: random.randint(0, 1000), number=n_repeats)\n",
    "print(f\"Builtin time: {1000*time_builtin / n_repeats:.6f} ms per call\")\n",
    "\n",
    "time_np = timeit.timeit(lambda: np.random.randint(0, 1000), number=n_repeats)\n",
    "print(f\"Numpy time: {1000*time_np / n_repeats:.6f} ms per call\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "coda_scratch",
   "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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}