From 7cf38a21ac88e952ecb3d36927a7859e04e4bcd7 Mon Sep 17 00:00:00 2001
From: Fischer Robert <fische_r@mpc2959.psi.ch>
Date: Mon, 8 Aug 2022 15:28:34 +0200
Subject: [PATCH] last saved version before quota issue

---
 .~pyTMLS_4D_test.ipynb | 1340 ++++++++++++++++++++++++++++++++++++++++
 pyTMLS_4D_test.ipynb   |  147 +++--
 2 files changed, 1449 insertions(+), 38 deletions(-)
 create mode 100644 .~pyTMLS_4D_test.ipynb

diff --git a/.~pyTMLS_4D_test.ipynb b/.~pyTMLS_4D_test.ipynb
new file mode 100644
index 0000000..dc61ec9
--- /dev/null
+++ b/.~pyTMLS_4D_test.ipynb
@@ -0,0 +1,1340 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d1c0f1c0-6da4-42f2-9911-7e2331b23b3a",
+   "metadata": {},
+   "source": [
+    "## Part 1: feature stack creation and saving"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d1b73384-f747-4c14-bbec-611b9f4ded5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# necessary packages for feature stack\n",
+    "import numpy as np\n",
+    "from scipy import ndimage\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from skimage import filters, feature, io\n",
+    "from skimage.morphology import disk,ball\n",
+    "\n",
+    "# from sklearn.ensemble import RandomForestClassifier\n",
+    "\n",
+    "import os\n",
+    "import imageio\n",
+    "import sys\n",
+    "import dask\n",
+    "import dask.array\n",
+    "# import cupy as cp\n",
+    "# import cucim\n",
+    "from itertools import combinations_with_replacement\n",
+    "import xarray as xr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47631229-5b13-468c-8b5e-38392e04c261",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "### 1.1 feature functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "50f7248b-5c6d-4187-9257-3871f5c657e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# functions take chunked dask-array as input\n",
+    "def nd_gaussian(da, sig = 0):\n",
+    "    if np.abs(sig-0)<0.1:\n",
+    "        G = np.array(da)\n",
+    "        fullname = 'original'\n",
+    "    else:\n",
+    "        deptharray = np.ones(da.ndim)+4*sig\n",
+    "        deptharray = tuple(np.min([deptharray, da.shape], axis=0))\n",
+    "        G = da.map_overlap(filters.gaussian, depth=deptharray, boundary='nearest', sigma = sig).compute()\n",
+    "        # G = da.map_overlap(filters.gaussian, depth=4*sig+1, boundary='none', sigma = sig).compute()\n",
+    "        fullname = ''.join(['gaussian_',f'{sig:.1f}'])\n",
+    "    return G, fullname\n",
+    "\n",
+    "#TODO create a class that makes the feature stacks\n",
+    "def nd_gaussian_stack(da, sigmas):\n",
+    "    fullnames = []\n",
+    "    gstack = np.zeros(list(da.shape) + [len(sigmas)])\n",
+    "    for sig,i in zip(sigmas, range(len(sigmas))):\n",
+    "        gstack[...,i], name = nd_gaussian(da, sig)\n",
+    "        fullnames.append(name)\n",
+    "    return gstack, fullnames"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "04d6fbf3-01c4-4d7b-bbd0-8b6271249979",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nd_diff_of_gaussian(gstack, sigmas):\n",
+    "#     #creates a stack of {size} (see below)\n",
+    "    n = len(sigmas)\n",
+    "    size = int(n*(n-1)/2)\n",
+    "    dstack = np.zeros(list(da.shape) + [size])\n",
+    "    fullnames = []\n",
+    "    cc = 0\n",
+    "    for i in range(1,n):\n",
+    "        for j in range(i):\n",
+    "            dstack[...,cc] = gstack[...,i] - gstack[...,j]\n",
+    "            name = ''.join(['diff_of_gauss_',f'{sigmas[i]:.1f}','_',f'{sigmas[j]:.1f}'])\n",
+    "            fullnames.append(name)\n",
+    "            cc = cc + 1\n",
+    "    return dstack, fullnames"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "02de82f3-ba96-4b85-a85a-b81a7f413a15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def ball_4d(sig):\n",
+    "    bnd = np.zeros((sig*2+1,sig*2+1,sig*2+1,sig*2+1), dtype = bool)\n",
+    "    bnd[sig,sig,sig,sig] = True\n",
+    "    ecd = ndimage.distance_transform_edt(~bnd)\n",
+    "    bnd = (ecd<sig+0.01).astype(int)\n",
+    "    return bnd\n",
+    "\n",
+    "def nd_rank_like_filter(da, sigma, option):\n",
+    "    \"\"\"\n",
+    "     input\n",
+    "     da - chunked das array up to 4D\n",
+    "     sigma - kernel size, scalar\n",
+    "     option, str ('minimum', 'maximum', 'median')\n",
+    "    \"\"\"\n",
+    "    if da.ndim == 2:\n",
+    "        fp = disk(sigma)\n",
+    "    if da.ndim == 3:\n",
+    "        fp = ball(sigma)\n",
+    "    if da.ndim == 4:\n",
+    "        fp = ball_4d(sigma)\n",
+    "        \n",
+    "    if option == 'minimum':\n",
+    "        fun = ndimage.minimum_filter\n",
+    "    elif option == 'maximum':\n",
+    "        fun = ndimage.maximum_filter\n",
+    "    elif option == 'median':\n",
+    "        fun = ndimage.median_filter\n",
+    "    else:\n",
+    "        print(option+' not available')\n",
+    "    deptharray = np.ones(da.ndim)+sigma\n",
+    "    deptharray = tuple(np.min([deptharray, da.shape], axis=0))\n",
+    "    M = da.map_overlap(fun, depth=deptharray, footprint=fp).compute()\n",
+    "    # M = da.map_overlap(fun, depth=sigma+1, footprint=fp).compute()\n",
+    "    fullname = ''.join([option,'_',f'{sigma:.1f}'])\n",
+    "    return M, fullname\n",
+    "\n",
+    "def nd_rank_like_stack(da, sigmas, option):\n",
+    "    fullnames = []\n",
+    "    mstack = np.zeros(list(da.shape) + [len(sigmas)-1])\n",
+    "    for sig,i in zip(sigmas[1:], range(len(sigmas)-1)):\n",
+    "        mstack[...,i], name = nd_rank_like_filter(da, sig, option)\n",
+    "        fullnames.append(name)\n",
+    "    return mstack, fullnames   \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "401c4f79-98a5-435a-a255-22bae402418d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nd_Hessian_matrix(G):\n",
+    "    \"\"\"\n",
+    "    copied from skimage.feature.hessian_matrix\n",
+    "    just directly using Gaussian fitered arrays and dask\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    daG = dask.array.from_array(G)\n",
+    "    gradients = dask.array.gradient(daG)\n",
+    "    axes = range(G.ndim)\n",
+    "    gradients = [gradients[ax0].compute() for ax0 in axes]\n",
+    "    H_elems = [dask.array.gradient(gradients[ax0], axis=ax1).compute() for ax0, ax1 in combinations_with_replacement(axes, 2)]\n",
+    "    elems = [(ax0,ax1) for ax0, ax1 in combinations_with_replacement(axes, 2)]\n",
+    "    return H_elems, elems, gradients\n",
+    "\n",
+    "def nd_Hessian_stack(G, sigma):\n",
+    "    H_elems, elems, gradients = nd_Hessian_matrix(G)\n",
+    "    hstack = np.zeros(list(G.shape)+[len(elems)])\n",
+    "    gradstack = np.zeros(list(G.shape)+[len(gradients)])\n",
+    "    \n",
+    "    #TODO: this is slow, find some better numpy function\n",
+    "    gradnames = []\n",
+    "    for i in range(len(elems)):\n",
+    "        hstack[...,i] = H_elems[i]\n",
+    "    for i in range(len(gradients)):\n",
+    "        gradnames.append(''.join(['gradient_',str(i),'_',f'{sigma:.1f}']))\n",
+    "        gradstack[...,i] = gradients[i]\n",
+    "    \n",
+    "    # print('got Hessian matrices, now doing the eigs')\n",
+    "    # eigs = feature.hessian_matrix_eigvals(H_elems) \n",
+    " # for now ignore the eigenvalues (too computationally expensive and H_elems already contains the image curvature  \n",
+    "\n",
+    "    fullnames = []\n",
+    "    for i,j in elems:\n",
+    "        fullname = ''.join(['hessian_',str(i),str(j),'_',f'{sigma:.1f}'])\n",
+    "        fullnames.append(fullname) \n",
+    "    \n",
+    "    stack = np.concatenate([hstack,gradstack], axis=-1)\n",
+    "    fullnames = fullnames+gradnames                         \n",
+    "        \n",
+    "    return stack, fullnames\n",
+    "\n",
+    "def nd_Hessian_stacks(gstack, sigmas):\n",
+    "    flag = True\n",
+    "    fullnames = []\n",
+    "    for (i, sigma) in zip(range(gstack.shape[-1]), sigmas):\n",
+    "        a, b = nd_Hessian_stack(gstack[...,i], sigma)\n",
+    "        asize = a.shape[-1]\n",
+    "        if flag:\n",
+    "            flag = False\n",
+    "            hstacks = np.zeros(list(gstack[...,-1].shape)+[len(sigmas)*asize])\n",
+    "        hstacks[...,i*asize:i*asize+asize] = a\n",
+    "        fullnames = fullnames + b\n",
+    "    return hstacks, fullnames"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "65898c62-240b-47ed-a137-5b93f7adb84f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def nd_feature_Stack(da, sigmas, feat_select):\n",
+    "#     TODO: make more elegant\n",
+    "    \n",
+    "    fstack = []\n",
+    "    featnames = []\n",
+    "    \n",
+    "    print('apply Gaussian filters anyway')\n",
+    "    gstack, gnames = nd_gaussian_stack(da, sigmas)\n",
+    "    \n",
+    "    if feat_select['Gaussian']:\n",
+    "        featnames = featnames + gnames\n",
+    "        fstack.append(gstack)\n",
+    "        \n",
+    "    if feat_select['Hessian']:\n",
+    "        print('get Hessian matrices')\n",
+    "        hstack, hnames = nd_Hessian_stacks(gstack, sigmas)\n",
+    "        featnames = featnames + hnames \n",
+    "        fstack.append(hstack)\n",
+    "        \n",
+    "    if feat_select['Diff of Gaussians']:\n",
+    "        print('get differences of Gaussians')\n",
+    "        dstack, dnames = nd_diff_of_gaussian(gstack, sigmas)\n",
+    "        featnames = featnames + dnames\n",
+    "        fstack.append(dstack)\n",
+    "        \n",
+    "    if feat_select['maximum']:\n",
+    "        print('apply maximum filters')\n",
+    "        maxstack, maxnames = nd_rank_like_stack(da, sigmas, option='maximum')\n",
+    "        featnames = featnames + maxnames\n",
+    "        fstack.append(maxstack)\n",
+    "        \n",
+    "    if feat_select['median']:\n",
+    "        print('apply median filters')\n",
+    "        medstack, mednames = nd_rank_like_stack(da, sigmas, option='median')\n",
+    "        featnames = featnames + mednames\n",
+    "        fstack.append(medstack)\n",
+    "        \n",
+    "    if feat_select['minimum']:\n",
+    "        print('apply minimum filters')\n",
+    "        minstack, minnames = nd_rank_like_stack(da, sigmas, option='minimum')\n",
+    "        featnames = featnames + minnames\n",
+    "        fstack.append(minstack)\n",
+    "        \n",
+    "    return np.concatenate(fstack, axis=-1), featnames\n",
+    "\n",
+    "def feat_stack_to_nc(fstack, featnames, path = None, name = 'test'):\n",
+    "    #TODO: include metadata and make general, now only 4D possible\n",
+    "    data = xr.Dataset({'feature_stack': (['x','y','z','time', 'feature'], fstack)},\n",
+    "                       coords = {'x': np.arange(fstack.shape[0]),\n",
+    "                                 'y': np.arange(fstack.shape[1]),\n",
+    "                                 'z': np.arange(fstack.shape[2]),\n",
+    "                                 'time': np.arange(fstack.shape[3]),\n",
+    "                                 'feature': featnames}\n",
+    "                      # attrs = feat_select\n",
+    "                     )\n",
+    "    # data.attrs['name'] = name\n",
+    "    if path is not None:\n",
+    "        data.to_netcdf(path)\n",
+    "    return data\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b206687-56a8-45d2-8b1c-7cf3366cdaf8",
+   "metadata": {},
+   "source": [
+    "### 1.2 load 4D dataset into dask-array TODO: employ datastreaming for datasets that are too large"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b88a88d1-9ac8-4621-849e-786d13d05a51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#TODO\n",
+    "da = None\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "a4720c60-4ebb-4e2c-b6af-ffe84602a0e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### provisoric manual loading of Jerermy's data\n",
+    "step1 = io.imread('/home/fische_r/NAS/testing/Jeremy_data/cropped/step_01.tif')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "b549b4e2-9485-43d9-ac5d-c88699a20ca1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1500, 39, 233)"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step1.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "24446742-5ddf-4719-a455-4403368da640",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "J_4D_data = np.zeros(list(step1.shape)+[8])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "5ed5a05f-83f7-49ae-8fed-e8eb226e4727",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "step_01.tif\n",
+      "step_02.tif\n",
+      "step_03.tif\n",
+      "step_04.tif\n",
+      "step_05.tif\n",
+      "step_06.tif\n",
+      "step_07.tif\n",
+      "step_08.tif\n"
+     ]
+    }
+   ],
+   "source": [
+    "folder = '/home/fische_r/NAS/testing/Jeremy_data/cropped'\n",
+    "files = os.listdir(folder)\n",
+    "files.sort()\n",
+    "for i in range(len(files)):\n",
+    "    print(files[i])\n",
+    "    J_4D_data[...,i] = io.imread(os.path.join(folder, files[i]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "f2f8871f-c3df-4290-89c1-dba2bef785db",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f8e6bf738b0>"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(J_4D_data[500,:,:,4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "f037d6a9-fa10-4904-869c-35cf9b56ab37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "step1=None\n",
+    "J_4D_data = J_4D_data[500:700,...]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "cca322a6-b907-4647-bae5-cf8f9e9703fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = xr.Dataset({'tomo': (['x','y','z','t'], J_4D_data)},\n",
+    "                  coords = {'x': np.arange(J_4D_data.shape[0]),\n",
+    "                            'y': np.arange(J_4D_data.shape[1]),\n",
+    "                            'z': np.arange(J_4D_data.shape[2]),\n",
+    "                            't': np.arange(J_4D_data.shape[3])})\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "5586ac1f-9516-4344-b1c9-e01a0b69a70b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data.to_netcdf(os.path.join(folder, 'tomodata.nc'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "35aaa579-91e7-43d2-a621-120d1ca6c971",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datapath = '/mpc/homes/fische_r/testing/tomodata.nc'\n",
+    "rawdata = xr.load_dataset(datapath)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "eaf95f61-52a7-4b9a-b31d-a1fb2e6be76e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "da = dask.array.from_array(rawdata['tomo'].data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7fa528a4-10a6-410a-9ac1-3415524fc60a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table>\n",
+       "    <tr>\n",
+       "        <td>\n",
+       "            <table>\n",
+       "                <thead>\n",
+       "                    <tr>\n",
+       "                        <td> </td>\n",
+       "                        <th> Array </th>\n",
+       "                        <th> Chunk </th>\n",
+       "                    </tr>\n",
+       "                </thead>\n",
+       "                <tbody>\n",
+       "                    \n",
+       "                    <tr>\n",
+       "                        <th> Bytes </th>\n",
+       "                        <td> 110.93 MiB </td>\n",
+       "                        <td> 110.93 MiB </td>\n",
+       "                    </tr>\n",
+       "                    \n",
+       "                    <tr>\n",
+       "                        <th> Shape </th>\n",
+       "                        <td> (200, 39, 233, 8) </td>\n",
+       "                        <td> (200, 39, 233, 8) </td>\n",
+       "                    </tr>\n",
+       "                    <tr>\n",
+       "                        <th> Count </th>\n",
+       "                        <td> 1 Tasks </td>\n",
+       "                        <td> 1 Chunks </td>\n",
+       "                    </tr>\n",
+       "                    <tr>\n",
+       "                    <th> Type </th>\n",
+       "                    <td> float64 </td>\n",
+       "                    <td> numpy.ndarray </td>\n",
+       "                    </tr>\n",
+       "                </tbody>\n",
+       "            </table>\n",
+       "        </td>\n",
+       "        <td>\n",
+       "        <svg width=\"452\" height=\"194\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"103\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"0\" y1=\"25\" x2=\"103\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"103\" y1=\"0\" x2=\"103\" y2=\"25\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"0.0,0.0 103.00429184549355,0.0 103.00429184549355,25.412616514582485 0.0,25.412616514582485\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"51.502146\" y=\"45.412617\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >200</text>\n",
+       "  <text x=\"123.004292\" y=\"12.706308\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,123.004292,12.706308)\">1</text>\n",
+       "\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"173\" y1=\"0\" x2=\"197\" y2=\"24\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"173\" y1=\"120\" x2=\"197\" y2=\"144\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"173\" y1=\"0\" x2=\"173\" y2=\"120\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"197\" y1=\"24\" x2=\"197\" y2=\"144\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"173.0,0.0 197.24915781783616,24.249157817836156 197.24915781783616,144.24915781783616 173.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"173\" y1=\"0\" x2=\"205\" y2=\"0\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"197\" y1=\"24\" x2=\"229\" y2=\"24\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"173\" y1=\"0\" x2=\"197\" y2=\"24\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"205\" y1=\"0\" x2=\"229\" y2=\"24\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"173.0,0.0 205.20356383232797,0.0 229.45272165016414,24.249157817836156 197.24915781783616,24.249157817836156\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Horizontal lines -->\n",
+       "  <line x1=\"197\" y1=\"24\" x2=\"229\" y2=\"24\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"197\" y1=\"144\" x2=\"229\" y2=\"144\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Vertical lines -->\n",
+       "  <line x1=\"197\" y1=\"24\" x2=\"197\" y2=\"144\" style=\"stroke-width:2\" />\n",
+       "  <line x1=\"229\" y1=\"24\" x2=\"229\" y2=\"144\" style=\"stroke-width:2\" />\n",
+       "\n",
+       "  <!-- Colored Rectangle -->\n",
+       "  <polygon points=\"197.24915781783616,24.249157817836156 229.45272165016414,24.249157817836156 229.45272165016414,144.24915781783616 197.24915781783616,144.24915781783616\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
+       "\n",
+       "  <!-- Text -->\n",
+       "  <text x=\"213.350940\" y=\"164.249158\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >8</text>\n",
+       "  <text x=\"249.452722\" y=\"84.249158\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,249.452722,84.249158)\">233</text>\n",
+       "  <text x=\"175.124579\" y=\"152.124579\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(45,175.124579,152.124579)\">39</text>\n",
+       "</svg>\n",
+       "        </td>\n",
+       "    </tr>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "dask.array<array, shape=(200, 39, 233, 8), dtype=float64, chunksize=(200, 39, 233, 8), chunktype=numpy.ndarray>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "da"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "815f4651-49a7-4669-8cc7-b3382f2e157a",
+   "metadata": {},
+   "source": [
+    "### 1.3 feature settings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f8ccaf6d-8921-4e94-ab6c-f0ff46432443",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigmas = [0, 1,4, 8]  #hard-coded for now, sobel and hessian require that first sigma is 0, diff, gaussian(sig=0) = 0\n",
+    "\n",
+    "# default feature choice\n",
+    "feat_select = {'Gaussian': True, \n",
+    "               # 'Sobel': True,\n",
+    "               'Hessian': True,\n",
+    "               'Diff of Gaussians': True,\n",
+    "               'maximum': True,\n",
+    "               'minimum': True,\n",
+    "               'median': True\n",
+    "              }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "2a00402e-a7bc-4eae-ad31-04950094df86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_dict = {}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9cd546b0-b13c-4403-a3c1-7a9f0cfb509a",
+   "metadata": {},
+   "source": [
+    "### 1.4 Create and store feature stack"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "cdb1c7b8-85bb-4707-b9ae-15716a621558",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#output path\n",
+    "outpath = '/mpc/homes/fische_r/testing/features.nc'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "ac1b5a84-f5b7-4174-b227-f6f1068382e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'feat_data' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfeat_data\u001b[49m\u001b[38;5;241m.\u001b[39mclose()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'feat_data' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "feat_data.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "39d1f364-d2c8-4fba-accf-931372c90622",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "apply Gaussian filters anyway\n",
+      "get Hessian matrices\n",
+      "get differences of Gaussians\n",
+      "apply maximum filters\n",
+      "apply median filters\n",
+      "apply minimum filters\n"
+     ]
+    }
+   ],
+   "source": [
+    "#this may take a while depending on the size and system\n",
+    "# may even crash because out of memory\n",
+    "\n",
+    "fstack, featnames = nd_feature_Stack(da, sigmas, feat_select)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 381,
+   "id": "21f3959b-f990-4765-9e2a-5fb15a3cb35e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "feat_data = feat_stack_to_nc(fstack, featnames, outpath, feat_select)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 382,
+   "id": "f118e8f3-4f2f-41ff-8727-e3ac67d1848a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fstack = None\n",
+    "data = None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "261ac0c2-2822-4426-a4a1-1fdb3260dd63",
+   "metadata": {},
+   "source": [
+    "## Part 2: Training the classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "06898513-bb61-4052-b95f-3c82a7f5c217",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# necessary packages\n",
+    "\n",
+    "#reload after kernel reset\n",
+    "import xarray as xr\n",
+    "import os\n",
+    "from skimage import io\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "#the classifier\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "#stuff for painting on the image\n",
+    "from ipywidgets import Image\n",
+    "from ipywidgets import ColorPicker, IntSlider, link, AppLayout, HBox\n",
+    "from ipycanvas import  hold_canvas,  MultiCanvas #RoughCanvas,Canvas,"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8330271b-005b-410b-9f50-c7572ce71f75",
+   "metadata": {},
+   "source": [
+    "### 2.1 open (not load) feature stack"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 612,
+   "id": "412e8e87-adcb-4351-ab29-1a701ecc5dc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "featpath =  '/mpc/homes/fische_r/testing/features.nc'\n",
+    "trainingpath = '/mpc/homes/fische_r/testing/'\n",
+    "# feat_data = xr.open_dataset(featpath)\n",
+    "feat_names = feat_data['feature'].data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09f055df-ca38-49d4-af3c-eb9048643051",
+   "metadata": {},
+   "source": [
+    "### 2.2 training functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "83050a3a-24c4-4aed-83a2-3ec1cdeffc42",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_training_data(im, truth, feat_stack):\n",
+    "    #pixelwise training data\n",
+    "    phase1 = truth==1\n",
+    "    phase2 = truth==2\n",
+    "    phase3 = truth==4   \n",
+    "    X1 = feat_stack[phase1]\n",
+    "    y1 = np.zeros(X1.shape[0])\n",
+    "    X2 = feat_stack[phase2]\n",
+    "    y2 = np.ones(X2.shape[0])\n",
+    "    X3 = feat_stack[phase3]\n",
+    "    y3 = 2*np.ones(X3.shape[0])\n",
+    "\n",
+    "    y = np.concatenate([y1,y2,y3])\n",
+    "    X = np.concatenate([X1,X2,X3])\n",
+    "    \n",
+    "    return X,y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "45efa62a-177f-4a07-a772-1cfb2c788347",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " def classify(X,y,im, feat_stack):\n",
+    "    # TODO: allow choice and manipulation of ML method\n",
+    "    clf =  RandomForestClassifier(n_estimators = 300, n_jobs=-1, random_state = 42, max_features=None) \n",
+    "    clf.fit(X, y)\n",
+    "    num_feat = feat_stack.shape[2]\n",
+    "    ypred = clf.predict(feat_stack.reshape(-1,num_feat))\n",
+    "    result = ypred.reshape(im.shape).astype(np.uint8)\n",
+    "    return result, clf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "id": "4661cd3a-04ef-4d5c-9d4e-a9059dce77b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def training_function(im, truth, feat_stack, training_dict, slice_name):\n",
+    "    flag = False\n",
+    "    slices = list(training_dict.keys())\n",
+    "    if slice_name in slices: \n",
+    "        slices.remove(slice_name)\n",
+    "    if len(slices)>0:\n",
+    "        flag = True\n",
+    "        Xall = training_dict[slices[0]][0]\n",
+    "        yall = training_dict[slices[0]][1]\n",
+    "        for i in range(1,len(slices)):\n",
+    "            Xall = np.concatenate([Xall, training_dict[slices[i]][0]])\n",
+    "            yall = np.concatenate([yall, training_dict[slices[i]][1]])\n",
+    "            \n",
+    "    X,y = extract_training_data(im, truth, feat_stack)\n",
+    "    \n",
+    "    print('training and classifying')\n",
+    "    \n",
+    "    if flag:\n",
+    "        Xt = np.concatenate([Xall,X])\n",
+    "        yt = np.concatenate([yall,y])\n",
+    "        Xall = None\n",
+    "        yall = None\n",
+    "    else:\n",
+    "        Xt = X\n",
+    "        yt = y  \n",
+    "    result, clf = classify(Xt, yt, im, feat_stack)\n",
+    "    \n",
+    "    # store training data of current slice in dict\n",
+    "    training_dict[slice_name] = (X,y)\n",
+    "    return result, clf, training_dict\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f521743-af65-49e7-979b-68be9f667ef4",
+   "metadata": {},
+   "source": [
+    "### 2.3 select 2D-slice and create a training set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "cbfeb471-f3d7-408d-8be5-2ffe60a2a7aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You could try  x = 113  and  time = 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# randomly suggest slice for training\n",
+    "# TODO: take coordinates from feat_data\n",
+    "dimensions = ['x','y','z','time']\n",
+    "\n",
+    "test_dims = np.random.choice(dimensions, 2, replace=False)\n",
+    "p1 = np.random.choice(range(len(feat_data[test_dims[0]])))\n",
+    "p2 = np.random.choice(range(len(feat_data[test_dims[1]])))\n",
+    "\n",
+    "print('You could try ',test_dims[0],'=',p1,' and ',test_dims[1],'=',p2)\n",
+    "# ts = np.random.choice(range(num_ts))+1\n",
+    "# print('try time step ',ts )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 600,
+   "id": "fa7cf1b7-2bc0-426e-b1ed-cb6bc86b909d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#select 2D slice orthogonal to these two axes\n",
+    "#replace dimensions in .sel accordingly, d1c and d2c are needed for filename\n",
+    "#TODO: make more elegant\n",
+    "d1c = 'z'\n",
+    "d2c = 'time'\n",
+    "p1c = 150\n",
+    "p2c = 7\n",
+    "im = feat_data['feature_stack'].sel(z = p1c, time = p2c, feature='original').data\n",
+    "im8 = np.uint8(im)\n",
+    "feat_stack = feat_data['feature_stack'].sel(z = p1c, time = p2c).data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 601,
+   "id": "c00812c5-2610-47b3-8577-fc915e96f5d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "im8 = im-im.min()\n",
+    "im8 = im8/im8.max()*255\n",
+    "im8old = im8.copy()\n",
+    "im8 = im8-50\n",
+    "im8[im8<0]=0\n",
+    "im8=im8*255/150\n",
+    "im8[im8>255] = 255"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 602,
+   "id": "a9c6932a-ce94-41ef-a06e-261962a1f38c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "slice_name = ''.join([str(d1c),str(p1c),str(d2c),str(p2c)])\n",
+    "truthpath = os.path.join(trainingpath, ''.join(['label_image_',slice_name,'.tif']))\n",
+    "\n",
+    "resultim = np.zeros(im.shape, dtype=np.uint8)\n",
+    "if os.path.exists(truthpath):\n",
+    "    truth = io.imread(truthpath)\n",
+    "    print('existing label set loaded')\n",
+    "else:\n",
+    "    truth = resultim.copy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff055922-4510-442b-bab6-f7ae5f1b339b",
+   "metadata": {},
+   "source": [
+    "### 2.4 training interface\n",
+    "currently only 3 phases possible <br />\n",
+    "manually specify #ff000 (phase 1) #00ff00 (phase 2) or #0000ff (phase 3) as color and paint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29033e9d-6678-43d7-8048-33184cd33d74",
+   "metadata": {},
+   "source": [
+    "#### 2.4.1 label data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 609,
+   "id": "a00a36de-acc2-459b-b5f4-41dee54120a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "726bfaf4f2e04497ab47ccbfd46db2b7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(MultiCanvas(height=200, width=39), ColorPicker(value='#ff0000', description='Color:'), IntSlide…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "width = im8.shape[1]\n",
+    "height = im8.shape[0]\n",
+    "\n",
+    "Mcanvas = MultiCanvas(4, width=width, height=height)\n",
+    "background = Mcanvas[0]\n",
+    "resultdisplay = Mcanvas[2]\n",
+    "truthdisplay = Mcanvas[1]\n",
+    "canvas = Mcanvas[3]\n",
+    "canvas.sync_image_data = True\n",
+    "\n",
+    "drawing = False\n",
+    "position = None\n",
+    "shape = []\n",
+    "\n",
+    "def on_mouse_down(x, y):\n",
+    "    global drawing\n",
+    "    global position\n",
+    "    global shape\n",
+    "\n",
+    "    drawing = True\n",
+    "    position = (x, y)\n",
+    "    shape = [position]\n",
+    "\n",
+    "def on_mouse_move(x, y):\n",
+    "    global drawing\n",
+    "    global position\n",
+    "    global shape\n",
+    "\n",
+    "    if not drawing:\n",
+    "        return\n",
+    "\n",
+    "    with hold_canvas():\n",
+    "        canvas.stroke_line(position[0], position[1], x, y)\n",
+    "\n",
+    "        position = (x, y)\n",
+    "\n",
+    "    shape.append(position)\n",
+    "\n",
+    "def on_mouse_up(x, y):\n",
+    "    global drawing\n",
+    "    global position\n",
+    "    global shape\n",
+    "\n",
+    "    drawing = False\n",
+    "\n",
+    "    with hold_canvas():\n",
+    "        canvas.stroke_line(position[0], position[1], x, y)\n",
+    "        canvas.fill_polygon(shape)\n",
+    "\n",
+    "    shape = []\n",
+    "\n",
+    "image_data = np.stack((im8, im8, im8), axis=2)\n",
+    "background.put_image_data(image_data, 0, 0)\n",
+    "\n",
+    "# image_data = np.stack((imdry, imdry, imdry), axis=2)\n",
+    "# background.put_image_data(image_data, width, 0)\n",
+    "\n",
+    "resultdisplay.global_alpha = 0.35\n",
+    "if np.any(resultim>0):\n",
+    "    result_data = np.stack((255*(resultim==0), 255*(resultim==1), 255*(resultim==2)), axis=2)\n",
+    "else:\n",
+    "    result_data = np.stack((0*resultim, 0*resultim, 0*resultim), axis=2)\n",
+    "resultdisplay.put_image_data(result_data, 0, 0)\n",
+    "\n",
+    "canvas.on_mouse_down(on_mouse_down)\n",
+    "canvas.on_mouse_move(on_mouse_move)\n",
+    "canvas.on_mouse_up(on_mouse_up)\n",
+    "\n",
+    "# canvas.stroke_style = \"#749cb8\"\n",
+    "# canvas.global_alpha = 0.75\n",
+    "\n",
+    "picker = ColorPicker(description=\"Color:\", value=\"#ff0000\")\n",
+    "slidealpha = IntSlider(description=\"Result overlay\", value=0.15)\n",
+    "\n",
+    "link((picker, \"value\"), (canvas, \"stroke_style\"))\n",
+    "link((picker, \"value\"), (canvas, \"fill_style\"))\n",
+    "# link((slidealpha, \"value\"), (resultdisplay, \"global_alpha\"))\n",
+    "\n",
+    "HBox((Mcanvas, picker, slidealpha))\n",
+    "#print('paint image with #ff0000 for air, #00ff00 for water and #0000ff for fiber')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 610,
+   "id": "8b8b1009-e121-48d6-ab12-a4b38aab8d47",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fbf34a81b80>"
+      ]
+     },
+     "execution_count": 610,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "diff = im8-imdry\n",
+    "diff[diff<0] = 0\n",
+    "fig, axes = plt.subplots(1,4)\n",
+    "axes[0].imshow(resultim==1)\n",
+    "axes[1].imshow(diff, 'gray')\n",
+    "axes[2].imshow(imdry, 'gray')\n",
+    "axes[3].imshow(im8, 'gray')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 607,
+   "id": "d58bc696-805d-4960-ab46-7ef830fc0577",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#create truth image from image, save to file\n",
+    "label_set = canvas.get_image_data()\n",
+    "\n",
+    "truth[label_set[:,:,0]>0] = 1\n",
+    "truth[label_set[:,:,1]>0] = 2\n",
+    "truth[label_set[:,:,2]>0] = 4\n",
+    "imageio.imsave(truthpath, truth)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb7ee2a2-ab53-4639-8016-fd804c779e3d",
+   "metadata": {},
+   "source": [
+    "#### 2.4.2 actual training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 608,
+   "id": "984c9694-7792-420c-945e-19004a8dc25e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "training and classifying\n"
+     ]
+    }
+   ],
+   "source": [
+    "resultim, clf, training_dict = training_function(im, truth, feat_stack, training_dict, slice_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "697a9253-88ac-4b7b-a891-6f14cb245b3d",
+   "metadata": {},
+   "source": [
+    "#### 2.4.3 iterative training: go back to 2.4.1 until good segmentation or try different slice at 2.3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89646a07-dd33-4159-931e-220a8c1126d6",
+   "metadata": {},
+   "source": [
+    "#### 2.4.4 plot classifier properties"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 613,
+   "id": "f43bda24-a965-40dd-bf6d-6c35216541e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_268297/1483009324.py:2: MatplotlibDeprecationWarning: Passing the linefmt parameter positionally is deprecated since Matplotlib 3.5; the parameter will become keyword-only two minor releases later.\n",
+      "  plt.stem(feat_names,clf.feature_importances_,'x')\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'importance')"
+      ]
+     },
+     "execution_count": 613,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x648 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure( figsize=(16,9))\n",
+    "plt.stem(feat_names,clf.feature_importances_,'x')\n",
+    "plt.xticks(rotation=90)\n",
+    "plt.ylabel('importance')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95286274-f5c7-475a-8bc4-f7242cf2be51",
+   "metadata": {},
+   "source": [
+    "## 3 apply classifier to full data set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "333187e2-e21c-49be-9770-95d872ab0eeb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#TODO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 470,
+   "id": "9adf4466-d54e-40b7-a05c-5a7d4bdbdbdd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_dict = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "9fb15524-6770-4423-8169-30c4f3908c9f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "da.ndim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "e730fe76-7541-4e0a-bbf4-4f261e33d386",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(200, 39, 233, 8)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "da.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c8133d05-a8ab-4fe1-824d-b232fb6cb47b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "deptharray = np.ones(da.ndim)+4\n",
+    "deptharray = np.max([deptharray, da.shape], axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "455ab1b9-00c3-4393-bab6-61736fb40a9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(200.0, 39.0, 233.0, 8.0)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tuple(deptharray)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6093818a-005e-49a6-af56-06d1b323ff54",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyTMLS_4D_test.ipynb b/pyTMLS_4D_test.ipynb
index f5d860c..dc61ec9 100644
--- a/pyTMLS_4D_test.ipynb
+++ b/pyTMLS_4D_test.ipynb
@@ -60,7 +60,10 @@
     "        G = np.array(da)\n",
     "        fullname = 'original'\n",
     "    else:\n",
-    "        G = da.map_overlap(filters.gaussian, depth=4*sig+1, sigma = sig).compute()\n",
+    "        deptharray = np.ones(da.ndim)+4*sig\n",
+    "        deptharray = tuple(np.min([deptharray, da.shape], axis=0))\n",
+    "        G = da.map_overlap(filters.gaussian, depth=deptharray, boundary='nearest', sigma = sig).compute()\n",
+    "        # G = da.map_overlap(filters.gaussian, depth=4*sig+1, boundary='none', sigma = sig).compute()\n",
     "        fullname = ''.join(['gaussian_',f'{sig:.1f}'])\n",
     "    return G, fullname\n",
     "\n",
@@ -99,7 +102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 15,
    "id": "02de82f3-ba96-4b85-a85a-b81a7f413a15",
    "metadata": {},
    "outputs": [],
@@ -133,7 +136,10 @@
     "        fun = ndimage.median_filter\n",
     "    else:\n",
     "        print(option+' not available')\n",
-    "    M = da.map_overlap(fun, depth=sigma+1, footprint=fp).compute()\n",
+    "    deptharray = np.ones(da.ndim)+sigma\n",
+    "    deptharray = tuple(np.min([deptharray, da.shape], axis=0))\n",
+    "    M = da.map_overlap(fun, depth=deptharray, footprint=fp).compute()\n",
+    "    # M = da.map_overlap(fun, depth=sigma+1, footprint=fp).compute()\n",
     "    fullname = ''.join([option,'_',f'{sigma:.1f}'])\n",
     "    return M, fullname\n",
     "\n",
@@ -149,28 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 370,
-   "id": "c6614dc5-ae4c-4fc9-af61-16a82bd2df0a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gradients = dask.array.gradient(da)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 373,
-   "id": "e951ab31-b487-4889-a65a-4173dc4b0667",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "axes = range(da.ndim)\n",
-    "test = [gradients[ax0].compute() for ax0 in axes]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 379,
+   "execution_count": 5,
    "id": "401c4f79-98a5-435a-a255-22bae402418d",
    "metadata": {},
    "outputs": [],
@@ -232,7 +217,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 6,
    "id": "65898c62-240b-47ed-a137-5b93f7adb84f",
    "metadata": {},
    "outputs": [],
@@ -460,7 +445,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "id": "35aaa579-91e7-43d2-a621-120d1ca6c971",
    "metadata": {},
    "outputs": [],
@@ -471,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 8,
    "id": "eaf95f61-52a7-4b9a-b31d-a1fb2e6be76e",
    "metadata": {},
    "outputs": [],
@@ -481,7 +466,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 9,
    "id": "7fa528a4-10a6-410a-9ac1-3415524fc60a",
    "metadata": {},
    "outputs": [
@@ -590,7 +575,7 @@
        "dask.array<array, shape=(200, 39, 233, 8), dtype=float64, chunksize=(200, 39, 233, 8), chunktype=numpy.ndarray>"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -609,12 +594,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 366,
+   "execution_count": 10,
    "id": "f8ccaf6d-8921-4e94-ab6c-f0ff46432443",
    "metadata": {},
    "outputs": [],
    "source": [
-    "sigmas = [0, 1]#,4, 8]  #hard-coded for now, sobel and hessian require that first sigma is 0, diff, gaussian(sig=0) = 0\n",
+    "sigmas = [0, 1,4, 8]  #hard-coded for now, sobel and hessian require that first sigma is 0, diff, gaussian(sig=0) = 0\n",
     "\n",
     "# default feature choice\n",
     "feat_select = {'Gaussian': True, \n",
@@ -629,7 +614,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 367,
+   "execution_count": 11,
    "id": "2a00402e-a7bc-4eae-ad31-04950094df86",
    "metadata": {},
    "outputs": [],
@@ -647,7 +632,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 104,
+   "execution_count": 12,
    "id": "cdb1c7b8-85bb-4707-b9ae-15716a621558",
    "metadata": {},
    "outputs": [],
@@ -658,17 +643,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 107,
+   "execution_count": 13,
    "id": "ac1b5a84-f5b7-4174-b227-f6f1068382e8",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'feat_data' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mfeat_data\u001b[49m\u001b[38;5;241m.\u001b[39mclose()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'feat_data' is not defined"
+     ]
+    }
+   ],
    "source": [
     "feat_data.close()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 380,
+   "execution_count": 16,
    "id": "39d1f364-d2c8-4fba-accf-931372c90622",
    "metadata": {},
    "outputs": [
@@ -1236,10 +1233,84 @@
     "training_dict = {}"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "9fb15524-6770-4423-8169-30c4f3908c9f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "da.ndim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "e730fe76-7541-4e0a-bbf4-4f261e33d386",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(200, 39, 233, 8)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "da.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c8133d05-a8ab-4fe1-824d-b232fb6cb47b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "deptharray = np.ones(da.ndim)+4\n",
+    "deptharray = np.max([deptharray, da.shape], axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "455ab1b9-00c3-4393-bab6-61736fb40a9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(200.0, 39.0, 233.0, 8.0)"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tuple(deptharray)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "f6d4b425-20d3-49da-8ab1-8502947f914a",
+   "id": "6093818a-005e-49a6-af56-06d1b323ff54",
    "metadata": {},
    "outputs": [],
    "source": []