Samples/jupyter/Filters.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example about OpenVisus filters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import OpenVisus and define utils:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os,sys\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from urllib.request import urlopen\n",
    "import matplotlib.pyplot as plt\n",
    "import shutil\n",
    "\n",
    "# import OpenVisus\n",
    "# sys.path.append(r\"C:\\projects\\OpenVisus\\build\\RelWithDebInfo\")\n",
    "from OpenVisus import *\n",
    "\n",
    "# utility\n",
    "def LoadImage(filename):\n",
    "\tif filename.startswith('http'):\n",
    "\t\tfilename=urlopen(filename) \n",
    "\treturn numpy.asarray(Image.open(filename))\n",
    "\n",
    "# utility\n",
    "def ShowImage(data,width=10):\n",
    "\tratio=float(data.shape[1])/data.shape[0]\n",
    "\tfig = plt.figure(figsize = (width,width*ratio))\n",
    "\tax = fig.add_subplot(1,1,1)\n",
    "\tax.imshow(data, origin='lower',cmap='viridis')\n",
    "\tplt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import your source data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded data (1388, 389, 1407, 1) float32\n"
     ]
    }
   ],
   "source": [
    "dtype=np.float32\n",
    "width,height,depth=1407,389,1388\n",
    "num_channels=1\n",
    "\n",
    "bGenerateFakeData=True\n",
    "\n",
    "if bGenerateFakeData:\n",
    "    # example of generating fake data (a white square in the middle)\n",
    "    data = np.zeros((depth, height, width,num_channels), dtype)\n",
    "    data[int(depth*1/4):int(depth*3/4),int(height*1/4):int(height*3/4),int(width*1/4):int(width*3/4), 0] = 1.0\n",
    "else:\n",
    "    # example of loading a file from *.raw file\n",
    "    filename=r'volume_1407x389x1388_float32.raw'\n",
    "    data = np.fromfile(filename, dtype=dtype).reshape((depth, height, width, num_channels))\n",
    "\n",
    "print(\"Loaded data\",data.shape,data.dtype)\n",
    "#ShowImage(data[int(depth/2),:,:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "About filters:\n",
    "- `identity` does NOT need an extra channel\n",
    "- `min` | `max` needs an extra channel (this about this: when I apply the inverse filter I need a way to know the original ordering)\n",
    "- discrete  `wavelet` (intXX)  needs an extra channel\n",
    "- continuos `wavelet` (floatXX) does NOT need an extra channel\n",
    "\n",
    "I need an extra channle for `max` filter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extra channel added (1388, 389, 1407, 2) float32\n"
     ]
    }
   ],
   "source": [
    "num_channels+=1\n",
    "new_data=numpy.zeros((depth, height, width, num_channels),dtype=data.dtype)\n",
    "new_data[:,:,:,0]=data[:,:,:,0]\n",
    "data=new_data\n",
    "print(\"Extra channel added\", data.shape, data.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the IDX directory from data. \n",
    "Note we are disabling compression here (`raw`) since `zip` is really slow. But in production you may want to use `zip` or `lz4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating idx...\n",
      "Writing data...\n",
      "idx file created\n"
     ]
    }
   ],
   "source": [
    "idx_filename='tmp/honeycomb_max_py.idx'\n",
    "print(\"Creating idx...\")\n",
    "compression=\"raw\"\n",
    "\n",
    "bDataInMemory=False\n",
    "\n",
    "# remove old directory if exists\n",
    "shutil.rmtree(os.path.dirname(idx_filename), ignore_errors=True)\n",
    "\n",
    "# example of writing data already in memory\n",
    "if bDataInMemory:\n",
    "    db = CreateIdx(\n",
    "        url=idx_filename, \n",
    "        dim=3, \n",
    "        data=data, \n",
    "        filters=['max'],\n",
    "        compression=compression)\n",
    "\n",
    "# example of writing data slice by slice (i.e. data not fitting in memory)\n",
    "else:\n",
    "    field=Field.fromString(\"DATA float32[{}] default_layout(row_major)\".format(num_channels))\n",
    "    db = CreateIdx(\n",
    "        url=idx_filename, \n",
    "        dim=3, \n",
    "        dims=(width,height,depth),\n",
    "        filters=['max'],\n",
    "        fields=[field],\n",
    "        compression=compression) \n",
    "    \n",
    "    # # z y x channel\n",
    "    # NOTE: if you have a row-major file here you need to read the file in place and return the data\n",
    "    def generateSlices():\n",
    "        for I in range(depth): \n",
    "            #print(\"Generating slice\",I)\n",
    "            yield data[I,:,:,:] \n",
    "\n",
    "    # NOTE: internally writeSlabs will accumulate slices up to some max_memsizse to maximize conversion speed\n",
    "    GB=1024*1024*1024\n",
    "    db.writeSlabs(generateSlices(),max_memsize=4*GB)\n",
    "\n",
    "print(\"idx file created\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute filter using a \"sliding window\" (sliding_box will be sliding_window^dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing filter...\n",
      "Filter computed\n"
     ]
    }
   ],
   "source": [
    "print(\"Computing filter...\")\n",
    "sliding_window=1024\n",
    "db.computeFilter(idx.getField(), sliding_window)\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x2586.12 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x2586.12 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x2599.38 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x2604.22 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "in general read will return a 3D region with 2 channels\n",
    "you need to \n",
    "    (*) get the first slice in Z of the the 3D block\n",
    "    (*) get the first channel (==drop the filter extra channel) \n",
    "\"\"\" \n",
    "middle=int(depth/2)\n",
    "for img in db.read(z=[middle,middle+1],num_refinements=4):\n",
    "    ShowImage(img[0,:,:,0] )"
   ]
  },
  {
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}