diff --git a/README.md b/README.md index 86c8312..0f7219a 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ -# diptorch - +diptorch +================ @@ -8,3 +8,66 @@ ``` sh pip install diptorch ``` + +## Hello, World! + +``` python +import matplotlib.pyplot as plt + +from diptorch.filters import gaussian_filter +from diptorch.utils import astronaut +``` + +``` python +# Zero-th order Gaussian filter (smoothing) +img = astronaut() +img_filtered = gaussian_filter(img, sigma=2.5) + +plt.figure(figsize=(6, 3)) +plt.subplot(121) +plt.imshow(img.squeeze(), cmap="gray") +plt.axis("off") +plt.subplot(122) +plt.imshow(img_filtered.squeeze(), cmap="gray") +plt.axis("off") +plt.tight_layout() +plt.show() +``` + +![](index_files/figure-commonmark/cell-3-output-1.png) + +``` python +# First-order Gaussian filter +img = astronaut() +img_filtered = gaussian_filter(img, sigma=2.5, order=1) + +plt.figure(figsize=(6, 3)) +plt.subplot(121) +plt.imshow(img.squeeze(), cmap="gray") +plt.axis("off") +plt.subplot(122) +plt.imshow(img_filtered.squeeze(), cmap="gray") +plt.axis("off") +plt.tight_layout() +plt.show() +``` + +![](index_files/figure-commonmark/cell-4-output-1.png) + +``` python +# Second-order Gaussian filter on the height dimension (y-axis) +img = astronaut() +img_filtered = gaussian_filter(img, sigma=2.5, order=[2, 0]) + +plt.figure(figsize=(6, 3)) +plt.subplot(121) +plt.imshow(img.squeeze(), cmap="gray") +plt.axis("off") +plt.subplot(122) +plt.imshow(img_filtered.squeeze(), cmap="gray") +plt.axis("off") +plt.tight_layout() +plt.show() +``` + +![](index_files/figure-commonmark/cell-5-output-1.png) diff --git a/diptorch/_modidx.py b/diptorch/_modidx.py index a720fc6..be2f74c 100644 --- a/diptorch/_modidx.py +++ b/diptorch/_modidx.py @@ -5,4 +5,10 @@ 'doc_host': 'https://eigenvivek.github.io', 'git_url': 'https://github.com/eigenvivek/diptorch', 'lib_path': 'diptorch'}, - 'syms': {'diptorch.filter': {'diptorch.filter.foo': ('filter.html#foo', 'diptorch/filter.py')}}} + 'syms': { 'diptorch.filters': { 'diptorch.filters._conv': ('filters.html#_conv', 'diptorch/filters.py'), + 'diptorch.filters._gaussian_kernel_1d': ('filters.html#_gaussian_kernel_1d', 'diptorch/filters.py'), + 'diptorch.filters._hessian_2d': ('filters.html#_hessian_2d', 'diptorch/filters.py'), + 'diptorch.filters._hessian_3d': ('filters.html#_hessian_3d', 'diptorch/filters.py'), + 'diptorch.filters.gaussian_filter': ('filters.html#gaussian_filter', 'diptorch/filters.py'), + 'diptorch.filters.hessian': ('filters.html#hessian', 'diptorch/filters.py')}, + 'diptorch.utils': {'diptorch.utils.astronaut': ('utils.html#astronaut', 'diptorch/utils.py')}}} diff --git a/diptorch/filter.py b/diptorch/filter.py deleted file mode 100644 index 6e5e8fb..0000000 --- a/diptorch/filter.py +++ /dev/null @@ -1,8 +0,0 @@ -# AUTOGENERATED! DO NOT EDIT! File to edit: ../notebooks/00_filter.ipynb. - -# %% auto 0 -__all__ = ['foo'] - -# %% ../notebooks/00_filter.ipynb 3 -def foo(): - pass diff --git a/diptorch/filters.py b/diptorch/filters.py new file mode 100644 index 0000000..ca794e5 --- /dev/null +++ b/diptorch/filters.py @@ -0,0 +1,134 @@ +# AUTOGENERATED! DO NOT EDIT! File to edit: ../notebooks/00_filters.ipynb. + +# %% auto 0 +__all__ = ['gaussian_filter', 'hessian'] + +# %% ../notebooks/00_filters.ipynb 3 +from math import ceil, sqrt +from typing import Callable + +import torch +import torch.nn.functional as F + +# %% ../notebooks/00_filters.ipynb 5 +def gaussian_filter( + img: torch.Tensor, # The input tensor + sigma: float, # Standard deviation for the Gaussian kernel + order: int | list = 0, # The order of the filter's derivative along each dim + mode: str = "reflect", # Padding mode for `torch.nn.functional.pad` + truncate: float = 4.0, # Number of standard deviations to sample the filter +) -> torch.Tensor: + """ + Convolves an image with a Gaussian kernel (or its derivatives). + + Inspired by the API of `scipy.ndimage.gaussian_filter` and the + implementation of `diplib.Gauss`. + """ + + # Specify the dimensions of the convolution to use + ndim = img.ndim - 2 + if isinstance(order, int): + order = [order] * ndim + else: + assert len(order) == ndim, "Specify the Gaussian derivative order for each dim" + convfn = getattr(F, f"conv{ndim}d") + + # Convolve along the rows, columns, and depth (optional) + for dim, derivative_order in enumerate(order): + img = _conv(img, convfn, sigma, derivative_order, truncate, mode, dim) + return img + +# %% ../notebooks/00_filters.ipynb 6 +def _gaussian_kernel_1d( + sigma: float, order: int, truncate: float, dtype: torch.dtype, device: torch.device +) -> torch.Tensor: + # Set the size of the kernel according to the sigma + radius = ceil(sigma * truncate) + x = torch.arange(-radius, radius + 1, dtype=dtype, device=device) + + # Initialize the zeroth-order Gaussian kernel + var = sigma**2 + g = (-x.pow(2) / (2 * var)).exp() / (sqrt(2 * torch.pi) * sigma) + + # Optionally convert to a higher-order kernel + if order == 0: + return g + elif order == 1: + g1 = g * (-x / var) + g1 -= g1.mean() + g1 /= (g1 * x).sum() / -1 # Normalize the filter's impulse response to -1 + return g1 + elif order == 2: + g2 = g * (x.pow(2) / var - 1) / var + g2 -= g2.mean() + g2 /= (g2 * x.pow(2)).sum() / 2 # Normalize the filter's impulse response to 2 + return g2 + else: + raise NotImplementedError(f"Only supports order in [0, 1, 2], not {order}") + + +def _conv( + img: torch.Tensor, + convfn: Callable, + sigma: float, + order: int, + truncate: float, + mode: str, + dim: int, +): + # Make a 1D kernel and pad such that the image size remains the same + kernel = _gaussian_kernel_1d(sigma, order, truncate, img.dtype, img.device) + padding = len(kernel) // 2 + + # Specify the padding dimensions + pad = [0] * 2 * (img.ndim - 2) + for idx in range(2 * dim, 2 * dim + 2): + pad[idx] = padding + pad = pad[::-1] + x = F.pad(img, pad, mode=mode) + + # Specify the dimension along which to do the convolution + view = [1] * img.ndim + view[dim + 2] *= -1 + + return convfn(x, weight=kernel.view(*view)) + +# %% ../notebooks/00_filters.ipynb 8 +def hessian(img: torch.Tensor, sigma: float, **kwargs) -> torch.Tensor: + """Compute the Hessian of a 2D or 3D image.""" + if img.ndim == 4: + return _hessian_2d(img, sigma, **kwargs) + elif img.ndim == 5: + return _hessian_3d(img, sigma, **kwargs) + else: + raise ValueError(f"img can only be 2D or 3D, not {img.ndim-2}D") + +# %% ../notebooks/00_filters.ipynb 9 +def _hessian_2d(img: torch.Tensor, sigma: float, **kwargs): + xx = gaussian_filter(img, sigma, order=[0, 2], **kwargs).squeeze() + yy = gaussian_filter(img, sigma, order=[2, 0], **kwargs).squeeze() + xy = gaussian_filter(img, sigma, order=[1, 1], **kwargs).squeeze() + return torch.stack( + [ + torch.stack([xx, xy], dim=-1), + torch.stack([xy, yy], dim=-1), + ], + dim=-1, + ) + + +def _hessian_3d(img: torch.Tensor, sigma: float, **kwargs): + xx = gaussian_filter(img, sigma, order=[0, 0, 2], **kwargs).squeeze() + yy = gaussian_filter(img, sigma, order=[0, 2, 0], **kwargs).squeeze() + zz = gaussian_filter(img, sigma, order=[2, 0, 0], **kwargs).squeeze() + xy = gaussian_filter(img, sigma, order=[0, 1, 1], **kwargs).squeeze() + xz = gaussian_filter(img, sigma, order=[1, 0, 1], **kwargs).squeeze() + yz = gaussian_filter(img, sigma, order=[1, 1, 0], **kwargs).squeeze() + return torch.stack( + [ + torch.stack([xx, xy, xz], dim=-1), + torch.stack([xy, yy, yz], dim=-1), + torch.stack([xz, yz, zz], dim=-1), + ], + dim=-1, + ) diff --git a/diptorch/utils.py b/diptorch/utils.py new file mode 100644 index 0000000..d1c680e --- /dev/null +++ b/diptorch/utils.py @@ -0,0 +1,18 @@ +# AUTOGENERATED! DO NOT EDIT! File to edit: ../notebooks/02_utils.ipynb. + +# %% auto 0 +__all__ = ['astronaut'] + +# %% ../notebooks/02_utils.ipynb 3 +import torch +from skimage import img_as_float +from skimage.color import rgb2gray +from skimage.data import astronaut as _astronaut + +# %% ../notebooks/02_utils.ipynb 4 +def astronaut(dtype: torch.dtype = torch.float32): + img = _astronaut() + img = img_as_float(img) + img = rgb2gray(img) + img = torch.from_numpy(img).to(dtype) + return img[None, None] diff --git a/environment.yml b/environment.yml index 02963e5..96a7644 100644 --- a/environment.yml +++ b/environment.yml @@ -5,4 +5,6 @@ channels: - nvidia dependencies: - pip - - pytorch \ No newline at end of file + - pytorch + - matplotlib + - scikit-image \ No newline at end of file diff --git a/index_files/figure-commonmark/cell-3-output-1.png b/index_files/figure-commonmark/cell-3-output-1.png new file mode 100644 index 0000000..3a27f0b Binary files /dev/null and b/index_files/figure-commonmark/cell-3-output-1.png differ diff --git a/index_files/figure-commonmark/cell-4-output-1.png b/index_files/figure-commonmark/cell-4-output-1.png new file mode 100644 index 0000000..9c83cda Binary files /dev/null and b/index_files/figure-commonmark/cell-4-output-1.png differ diff --git a/index_files/figure-commonmark/cell-5-output-1.png b/index_files/figure-commonmark/cell-5-output-1.png new file mode 100644 index 0000000..83fca5e Binary files /dev/null and b/index_files/figure-commonmark/cell-5-output-1.png differ diff --git a/notebooks/00_filters.ipynb b/notebooks/00_filters.ipynb new file mode 100644 index 0000000..1cab0a8 --- /dev/null +++ b/notebooks/00_filters.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# filters\n", + "\n", + "> Linear convolution filters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| default_exp filters" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "from nbdev.showdoc import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "from math import ceil, sqrt\n", + "from typing import Callable\n", + "\n", + "import torch\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gaussian filter\n", + "\n", + "Implements filtering with a $k$-order Gaussian derivative as a series of 1D convolutions. Currently supports up to second-order derivatives." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def gaussian_filter(\n", + " img: torch.Tensor, # The input tensor\n", + " sigma: float, # Standard deviation for the Gaussian kernel\n", + " order: int | list = 0, # The order of the filter's derivative along each dim\n", + " mode: str = \"reflect\", # Padding mode for `torch.nn.functional.pad`\n", + " truncate: float = 4.0, # Number of standard deviations to sample the filter\n", + ") -> torch.Tensor:\n", + " \"\"\"\n", + " Convolves an image with a Gaussian kernel (or its derivatives).\n", + "\n", + " Inspired by the API of `scipy.ndimage.gaussian_filter` and the\n", + " implementation of `diplib.Gauss`.\n", + " \"\"\"\n", + "\n", + " # Specify the dimensions of the convolution to use\n", + " ndim = img.ndim - 2\n", + " if isinstance(order, int):\n", + " order = [order] * ndim\n", + " else:\n", + " assert len(order) == ndim, \"Specify the Gaussian derivative order for each dim\"\n", + " convfn = getattr(F, f\"conv{ndim}d\")\n", + "\n", + " # Convolve along the rows, columns, and depth (optional)\n", + " for dim, derivative_order in enumerate(order):\n", + " img = _conv(img, convfn, sigma, derivative_order, truncate, mode, dim)\n", + " return img" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "def _gaussian_kernel_1d(\n", + " sigma: float, order: int, truncate: float, dtype: torch.dtype, device: torch.device\n", + ") -> torch.Tensor:\n", + " # Set the size of the kernel according to the sigma\n", + " radius = ceil(sigma * truncate)\n", + " x = torch.arange(-radius, radius + 1, dtype=dtype, device=device)\n", + "\n", + " # Initialize the zeroth-order Gaussian kernel\n", + " var = sigma**2\n", + " g = (-x.pow(2) / (2 * var)).exp() / (sqrt(2 * torch.pi) * sigma)\n", + "\n", + " # Optionally convert to a higher-order kernel\n", + " if order == 0:\n", + " return g\n", + " elif order == 1:\n", + " g1 = g * (-x / var)\n", + " g1 -= g1.mean()\n", + " g1 /= (g1 * x).sum() / -1 # Normalize the filter's impulse response to -1\n", + " return g1\n", + " elif order == 2:\n", + " g2 = g * (x.pow(2) / var - 1) / var\n", + " g2 -= g2.mean()\n", + " g2 /= (g2 * x.pow(2)).sum() / 2 # Normalize the filter's impulse response to 2\n", + " return g2\n", + " else:\n", + " raise NotImplementedError(f\"Only supports order in [0, 1, 2], not {order}\")\n", + "\n", + "\n", + "def _conv(\n", + " img: torch.Tensor,\n", + " convfn: Callable,\n", + " sigma: float,\n", + " order: int,\n", + " truncate: float,\n", + " mode: str,\n", + " dim: int,\n", + "):\n", + " # Make a 1D kernel and pad such that the image size remains the same\n", + " kernel = _gaussian_kernel_1d(sigma, order, truncate, img.dtype, img.device)\n", + " padding = len(kernel) // 2\n", + "\n", + " # Specify the padding dimensions\n", + " pad = [0] * 2 * (img.ndim - 2)\n", + " for idx in range(2 * dim, 2 * dim + 2):\n", + " pad[idx] = padding\n", + " pad = pad[::-1]\n", + " x = F.pad(img, pad, mode=mode)\n", + "\n", + " # Specify the dimension along which to do the convolution\n", + " view = [1] * img.ndim\n", + " view[dim + 2] *= -1\n", + "\n", + " return convfn(x, weight=kernel.view(*view))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hessian matrix of an image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def hessian(img: torch.Tensor, sigma: float, **kwargs) -> torch.Tensor:\n", + " \"\"\"Compute the Hessian of a 2D or 3D image.\"\"\"\n", + " if img.ndim == 4:\n", + " return _hessian_2d(img, sigma, **kwargs)\n", + " elif img.ndim == 5:\n", + " return _hessian_3d(img, sigma, **kwargs)\n", + " else:\n", + " raise ValueError(f\"img can only be 2D or 3D, not {img.ndim-2}D\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "def _hessian_2d(img: torch.Tensor, sigma: float, **kwargs):\n", + " xx = gaussian_filter(img, sigma, order=[0, 2], **kwargs).squeeze()\n", + " yy = gaussian_filter(img, sigma, order=[2, 0], **kwargs).squeeze()\n", + " xy = gaussian_filter(img, sigma, order=[1, 1], **kwargs).squeeze()\n", + " return torch.stack(\n", + " [\n", + " torch.stack([xx, xy], dim=-1),\n", + " torch.stack([xy, yy], dim=-1),\n", + " ],\n", + " dim=-1,\n", + " )\n", + "\n", + "\n", + "def _hessian_3d(img: torch.Tensor, sigma: float, **kwargs):\n", + " xx = gaussian_filter(img, sigma, order=[0, 0, 2], **kwargs).squeeze()\n", + " yy = gaussian_filter(img, sigma, order=[0, 2, 0], **kwargs).squeeze()\n", + " zz = gaussian_filter(img, sigma, order=[2, 0, 0], **kwargs).squeeze()\n", + " xy = gaussian_filter(img, sigma, order=[0, 1, 1], **kwargs).squeeze()\n", + " xz = gaussian_filter(img, sigma, order=[1, 0, 1], **kwargs).squeeze()\n", + " yz = gaussian_filter(img, sigma, order=[1, 1, 0], **kwargs).squeeze()\n", + " return torch.stack(\n", + " [\n", + " torch.stack([xx, xy, xz], dim=-1),\n", + " torch.stack([xy, yy, yz], dim=-1),\n", + " torch.stack([xz, yz, zz], dim=-1),\n", + " ],\n", + " dim=-1,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#| hide\n", + "import nbdev\n", + "\n", + "nbdev.nbdev_export()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/00_filter.ipynb b/notebooks/02_utils.ipynb similarity index 50% rename from notebooks/00_filter.ipynb rename to notebooks/02_utils.ipynb index d4067b0..909c17e 100644 --- a/notebooks/00_filter.ipynb +++ b/notebooks/02_utils.ipynb @@ -2,25 +2,28 @@ "cells": [ { "cell_type": "markdown", + "id": "84b24755-6f20-408a-8512-bedbb281d7bb", "metadata": {}, "source": [ - "# filter\n", + "# utils\n", "\n", - "> Linear convolution filters" + "> Utility functions" ] }, { "cell_type": "code", "execution_count": null, + "id": "cab18724-566d-48d9-a83b-ee3750096a6e", "metadata": {}, "outputs": [], "source": [ - "#| default_exp filter" + "#| default_exp utils" ] }, { "cell_type": "code", "execution_count": null, + "id": "7c9f7022-b5e0-47fe-88ac-2e56e4906103", "metadata": {}, "outputs": [], "source": [ @@ -31,17 +34,37 @@ { "cell_type": "code", "execution_count": null, + "id": "00e971d6-d9d2-49d6-a8fb-06dfab8ee223", "metadata": {}, "outputs": [], "source": [ "#| export\n", - "def foo():\n", - " pass" + "import torch\n", + "from skimage import img_as_float\n", + "from skimage.color import rgb2gray\n", + "from skimage.data import astronaut as _astronaut" ] }, { "cell_type": "code", "execution_count": null, + "id": "3f690776-6e19-4438-a96e-c997295d6256", + "metadata": {}, + "outputs": [], + "source": [ + "#| export\n", + "def astronaut(dtype: torch.dtype = torch.float32):\n", + " img = _astronaut()\n", + " img = img_as_float(img)\n", + " img = rgb2gray(img)\n", + " img = torch.from_numpy(img).to(dtype)\n", + " return img[None, None]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85a82e34-6575-4eca-bf40-f482df938130", "metadata": {}, "outputs": [], "source": [ @@ -54,6 +77,7 @@ { "cell_type": "code", "execution_count": null, + "id": "97b5bac4-6488-4c92-a8f7-bac246e2ebf3", "metadata": {}, "outputs": [], "source": [] @@ -64,15 +88,8 @@ "display_name": "python3", "language": "python", "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 5 } diff --git a/notebooks/index.ipynb b/notebooks/index.ipynb index 8fd388a..209cb5d 100644 --- a/notebooks/index.ipynb +++ b/notebooks/index.ipynb @@ -25,6 +25,121 @@ "```" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hello, World!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from diptorch.filters import gaussian_filter\n", + "from diptorch.utils import astronaut" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Zero-th order Gaussian filter (smoothing)\n", + "img = astronaut()\n", + "img_filtered = gaussian_filter(img, sigma=2.5)\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "plt.subplot(121)\n", + "plt.imshow(img.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.subplot(122)\n", + "plt.imshow(img_filtered.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First-order Gaussian filter\n", + "img = astronaut()\n", + "img_filtered = gaussian_filter(img, sigma=2.5, order=1)\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "plt.subplot(121)\n", + "plt.imshow(img.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.subplot(122)\n", + "plt.imshow(img_filtered.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Second-order Gaussian filter on the height dimension (y-axis)\n", + "img = astronaut()\n", + "img_filtered = gaussian_filter(img, sigma=2.5, order=[2, 0])\n", + "\n", + "plt.figure(figsize=(6, 3))\n", + "plt.subplot(121)\n", + "plt.imshow(img.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.subplot(122)\n", + "plt.imshow(img_filtered.squeeze(), cmap=\"gray\")\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/settings.ini b/settings.ini index bbaab8e..a75d36c 100644 --- a/settings.ini +++ b/settings.ini @@ -38,7 +38,7 @@ status = 3 user = eigenvivek ### Optional ### -requirements = +requirements = matplotlib scikit-image pip_requirements = torch conda_requirements = pytorch dev_requirements = nbdev black flake8 ipykernel ipywidgets jupyterlab jupyterlab_execute_time jupyterlab-code-formatter isort