From d1fe31cf32533ed57ffde8aa939d2bf26138e2b2 Mon Sep 17 00:00:00 2001
From: Sebastien Jourdain <sebastien.jourdain@kitware.com>
Date: Wed, 30 Oct 2024 15:24:54 -0600
Subject: [PATCH] feat(xarray): add slicing and compute in algo

---
 examples/jupyter/test-xarray.ipynb | 178 ++++++------------
 pan3d/explorers/data_viewer.py     |   9 +
 pan3d/xarray/__source.py           | 290 -----------------------------
 pan3d/xarray/accessor.py           |  44 ++---
 pan3d/xarray/algorithm.py          | 108 +++++++++--
 5 files changed, 183 insertions(+), 446 deletions(-)
 delete mode 100644 pan3d/xarray/__source.py

diff --git a/examples/jupyter/test-xarray.ipynb b/examples/jupyter/test-xarray.ipynb
index 4e9f011..61364f2 100644
--- a/examples/jupyter/test-xarray.ipynb
+++ b/examples/jupyter/test-xarray.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "88a3053b-a228-4099-8bd8-d92abaae317b",
    "metadata": {},
    "outputs": [],
@@ -24,172 +24,118 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "41a4ebf1-8b90-4709-8d4c-06efb3afcc51",
-   "metadata": {
-    "collapsed": true,
-    "jupyter": {
-     "outputs_hidden": true
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/sebastien.jourdain/Documents/code/sbir/pan3d/.venv/lib/python3.10/site-packages/xarray/conventions.py:286: SerializationWarning: variable 'z' has non-conforming '_FillValue' np.float64(nan) defined, dropping '_FillValue' entirely.\n",
-      "  var = coder.decode(var, name=name)\n",
-      "/Users/sebastien.jourdain/Documents/code/sbir/pan3d/.venv/lib/python3.10/site-packages/xarray/conventions.py:286: SerializationWarning: variable 'u' has non-conforming '_FillValue' np.float64(nan) defined, dropping '_FillValue' entirely.\n",
-      "  var = coder.decode(var, name=name)\n",
-      "/Users/sebastien.jourdain/Documents/code/sbir/pan3d/.venv/lib/python3.10/site-packages/xarray/conventions.py:286: SerializationWarning: variable 'v' has non-conforming '_FillValue' np.float64(nan) defined, dropping '_FillValue' entirely.\n",
-      "  var = coder.decode(var, name=name)\n"
-     ]
-    }
-   ],
+   "metadata": {},
+   "outputs": [],
    "source": [
     "dataset = open_dataset(\"eraint_uvz\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "54c88fe2-176a-4468-89e3-3dbf2979776a",
-   "metadata": {
-    "collapsed": true,
-    "jupyter": {
-     "outputs_hidden": true
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "ERROR:root:Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*iHat + v*jHat\n",
-      "ERROR:root:Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*iHat + v*jHat\n",
-      "ERROR:root:Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*u + v*v\n",
-      "ERROR:root:Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*u + v*v\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<vtkmodules.util.execution_model.Pipeline object at 0x146673010>\n"
-     ]
-    }
-   ],
-   "source": [
-    "viewer = XArrayViewer()\n",
-    "await viewer.ui.ready"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "c78e6b6c-6ea0-4f46-ada1-8760ed86474f",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "fbd9427e7e9e437fb5ac8e0de61dc9c3",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "HTML(value='<iframe id=\"trame_trame__template_main\" src=\"http://localhost:55794/index.html?ui=main&reconnect=a…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[0m\u001b[31m2024-10-29 17:38:35.710 (  33.601s) [          1C7CDB]vtkExprTkFunctionParser:481    ERR| vtkExprTkFunctionParser (0x15c353e50): Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*iHat + v*jHat\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[31m2024-10-29 17:38:35.710 (  33.601s) [          1C7CDB]vtkExprTkFunctionParser:481    ERR| vtkExprTkFunctionParser (0x15c353e50): Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*iHat + v*jHat\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[33m2024-10-29 17:38:35.711 (  33.602s) [          1C7CDB] vtkArrayCalculator.cxx:581   WARN| vtkArrayCalculator (0x1420eb080): An error occurred when parsing the calculator's function.  See previous errors.\u001b[0m\n",
-      "\u001b[0m\u001b[31m2024-10-29 17:38:35.711 (  33.602s) [          1C7CDB]vtkExprTkFunctionParser:481    ERR| vtkExprTkFunctionParser (0x15c3632a0): Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*u + v*v\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[31m2024-10-29 17:38:35.711 (  33.602s) [          1C7CDB]vtkExprTkFunctionParser:481    ERR| vtkExprTkFunctionParser (0x15c3632a0): Err: 0 Type: [Syntax Error] Msg: ERR201 - Undefined symbol: 'u'\tExpression: u*u + v*v\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[33m2024-10-29 17:38:35.712 (  33.603s) [          1C7CDB] vtkArrayCalculator.cxx:581   WARN| vtkArrayCalculator (0x1420eb4a0): An error occurred when parsing the calculator's function.  See previous errors.\u001b[0m\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
+    "viewer = XArrayViewer()\n",
+    "await viewer.ui.ready\n",
     "viewer.xarray = dataset\n",
-    "\n",
-    "viewer.source.order = \"F\" \n",
-    "viewer.source.computed = {\n",
+    "viewer.computed = {\n",
+    "    \"_use_scalars\": [\"u\", \"v\"], # optional if empty\n",
+    "    \"_use_vectors\": [], # optional if empty\n",
     "    \"vec\": \"u*iHat + v*jHat\",\n",
     "    \"mag\": \"u*u + v*v\",\n",
     "}\n",
-    "\n",
-    "viewer.ui"
+    "source = viewer.source"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5f993b87-c96c-496b-a819-f08cb2c8d06a",
+   "id": "1a3db2e2-70f5-41f9-b429-bc0d9c1674ab",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "viewer.ui"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "6646794d-151a-4e3f-9e3a-b0fad4451719",
+   "id": "c3bb5924-a1f4-4f0b-8f14-77ccbc66b251",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pan3d.xarray.algorithm import vtkXArrayRectilinearSource\n",
+    "import pyvista as pv\n",
     "\n",
-    "algo = vtkXArrayRectilinearSource(dataset)"
+    "plotter = pv.Plotter()\n",
+    "plotter.add_mesh(source, scalars=\"mag\", cmap='coolwarm')\n",
+    "plotter.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c3bb5924-a1f4-4f0b-8f14-77ccbc66b251",
+   "id": "d5a338fe-6997-4f2e-a237-d972415d1249",
    "metadata": {},
    "outputs": [],
    "source": [
-    "viewer.show(algo)"
+    "import ipywidgets as widgets\n",
+    "\n",
+    "def update_level(change):\n",
+    "    source.slicing = {\n",
+    "        **source.slicing,\n",
+    "        source.z: change.new, \n",
+    "    }\n",
+    "    viewer.reset_camera()\n",
+    "    plotter.render()\n",
+    "\n",
+    "def update_resolution(change):\n",
+    "    v = source.slicing\n",
+    "    v[source.x] = [0, -1, change.new]\n",
+    "    v[source.y] = [0, -1, change.new]\n",
+    "    source.slicing = v\n",
+    "    viewer.reset_camera()\n",
+    "    plotter.render()\n",
+    "\n",
+    "slider_level = widgets.IntSlider(value=0, min=0, max=(viewer.xarray[viewer.source.z].size - 1), step=1, description=viewer.source.z)\n",
+    "slider_level.observe(update_level, names='value')\n",
+    "slider_resolution = widgets.IntSlider(value=1, min=1, max=10, step=1, description=\"resolution\")\n",
+    "slider_resolution.observe(update_resolution, names='value')\n",
+    "widgets.HBox([slider_level, slider_resolution])"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "e52221f9-3620-4605-9dae-26747474337f",
-   "metadata": {},
+   "id": "ad74227e-ea49-44fc-89d7-f4a5c95b5cf6",
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [],
    "source": [
-    "print(viewer.source())\n"
+    "print(source)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a1db60e3-5642-4580-aac5-66646f285544",
+   "id": "6646794d-151a-4e3f-9e3a-b0fad4451719",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "from pan3d.xarray.algorithm import vtkXArrayRectilinearSource\n",
+    "\n",
+    "algo = vtkXArrayRectilinearSource(dataset)\n",
+    "algo.computed = {\n",
+    "    \"_use_scalars\": [\"u\", \"v\"], # optional if empty\n",
+    "    \"_use_vectors\": [], # optional if empty\n",
+    "    \"vec\": \"u*iHat + v*jHat\",\n",
+    "    \"mag\": \"u*u + v*v\",\n",
+    "}"
+   ]
   }
  ],
  "metadata": {
diff --git a/pan3d/explorers/data_viewer.py b/pan3d/explorers/data_viewer.py
index 0b5df6b..b3f9ac1 100644
--- a/pan3d/explorers/data_viewer.py
+++ b/pan3d/explorers/data_viewer.py
@@ -74,6 +74,15 @@ def xarray(self, value):
         self.actor.visibility = 1
         self.reset_camera()
 
+    @property
+    def computed(self):
+        return self.source.computed
+
+    @computed.setter
+    def computed(self, value):
+        self.source.computed = value
+        self.refresh_data()
+
     def update(self):
         self.ctrl.view_update()
 
diff --git a/pan3d/xarray/__source.py b/pan3d/xarray/__source.py
deleted file mode 100644
index 85c2f66..0000000
--- a/pan3d/xarray/__source.py
+++ /dev/null
@@ -1,290 +0,0 @@
-import traceback
-from typing import List, Optional
-
-import numpy as np
-import pyvista as pv
-from vtkmodules.util.vtkAlgorithm import VTKPythonAlgorithmBase
-import xarray as xr
-
-
-class BaseSource(VTKPythonAlgorithmBase):
-    def __init__(self, nOutputPorts=1, outputType="vtkTable", **kwargs):
-        VTKPythonAlgorithmBase.__init__(
-            self,
-            nInputPorts=0,
-            nOutputPorts=nOutputPorts,
-            outputType=outputType,
-            **kwargs,
-        )
-
-    def GetOutput(self, port=0):
-        output = pv.wrap(self.GetOutputDataObject(port))
-        if output.active_scalars is None and output.n_arrays:
-            if len(output.point_data):
-                output.set_active_scalars(output.point_data.keys()[0])
-            elif len(output.cell_data):
-                output.set_active_scalars(output.cell_data.keys()[0])
-        return output
-
-    def apply(self):
-        self.Update()
-        return self.GetOutput()
-
-    def update(self):
-        """Alias for self.Update()"""
-        return self.Update()
-
-    def get_output(self, port=0):
-        """Alias for self.GetOutput()"""
-        return self.GetOutput(port=port)
-
-
-class PyVistaXarraySource(BaseSource):
-    def __init__(
-        self,
-        data_array: Optional[xr.DataArray] = None,
-        x: Optional[str] = None,
-        y: Optional[str] = None,
-        z: Optional[str] = None,
-        time: Optional[str] = None,
-        order: str = "C",
-        component: Optional[str] = None,
-        mesh_type: Optional[str] = None,
-        resolution: Optional[float] = None,
-    ):
-        BaseSource.__init__(
-            self,
-            nOutputPorts=1,
-            outputType="vtkRectilinearGrid",
-        )
-        self._data_array = data_array
-        self._resolution = resolution
-
-        self._x = x
-        self._y = y
-        self._z = z
-        self._order = order
-        self._component = component
-        self._mesh_type = mesh_type
-
-        self._time = None
-        self._time_index = 0
-        if isinstance(time, str):
-            self._time = time
-        elif time is not None:
-            raise TypeError
-
-        self._z_index = None
-        self._slicing = None
-        self._sliced_data_array = None
-        self._persisted_data = None
-        self._mesh = None
-
-    def __str__(self):
-        return f"""
-data_array: {self._data_array}
-resolution: {self._resolution}
-x: {self._x}
-y: {self._y}
-z: {self._z}
-order: {self._order}
-component: {self._component}
-time: {self._time}
-time_index: {self._time_index}
-"""
-
-    @property
-    def data_array(self):
-        return self._data_array
-
-    @data_array.setter
-    def data_array(self, data_array):
-        self._data_array = data_array
-        self.Modified()
-
-    @property
-    def resolution(self):
-        return self._resolution
-
-    @resolution.setter
-    def resolution(self, resolution: int):
-        self._resolution = resolution
-        self.Modified()
-
-    @property
-    def x(self):
-        return self._x
-
-    @x.setter
-    def x(self, x: str):
-        self._x = x
-        self.Modified()
-
-    @property
-    def y(self):
-        return self._y
-
-    @y.setter
-    def y(self, y: str):
-        self._y = y
-        self.Modified()
-
-    @property
-    def z(self):
-        return self._z
-
-    @z.setter
-    def z(self, z: str):
-        self._z = z
-        self.Modified()
-
-    @property
-    def time(self):
-        return self._time
-
-    @time.setter
-    def time(self, time: str):
-        self._time = time
-        self.Modified()
-
-    @property
-    def order(self):
-        return self._order
-
-    @order.setter
-    def order(self, order: str):
-        self._order = order
-        self.Modified()
-
-    @property
-    def component(self):
-        return self._component
-
-    @component.setter
-    def component(self, component: str):
-        self._component = component
-        self.Modified()
-
-    @property
-    def time_index(self):
-        return self._time_index
-
-    @time_index.setter
-    def time_index(self, time_index: int):
-        self._time_index = time_index
-        self.Modified()
-
-    @property
-    def max_time_index(self):
-        if self._time:
-            return len(self.data_array[self._time]) - 1
-
-    @property
-    def z_index(self):
-        return self._z_index
-
-    @z_index.setter
-    def z_index(self, z_index: int):
-        self._z_index = z_index
-        self.Modified()
-
-    @property
-    def slicing(self):
-        return self._slicing
-
-    @slicing.setter
-    def slicing(self, slicing: Optional[List[int]]):
-        self._slicing = slicing
-        self.Modified()
-
-    @property
-    def sliced_data_array(self):
-        if self._sliced_data_array is None:
-            self._compute_sliced_data_array()
-        return self._sliced_data_array
-
-    @property
-    def persisted_data(self):
-        if self._persisted_data is None:
-            self._persisted_data = self.sliced_data_array.persist()
-        return self._persisted_data
-
-    @property
-    def mesh(self):
-        if self._mesh is None:
-            self._compute_mesh()
-        return self._mesh
-
-    @property
-    def data_range(self):
-        da = self.persisted_data
-        return da.min(), da.max()
-
-    def resolution_to_sampling_rate(self, data_array):
-        """Convert percentage to sampling rate."""
-        shape = np.array(data_array.shape)
-        n = np.floor(shape * self._resolution)
-        rate = np.ceil(shape / n).astype(int)
-        return np.pad(rate, (0, 3 - len(rate)), mode="constant")
-
-    def _compute_sliced_data_array(self):
-        if self.data_array is None:
-            self._sliced_data_array = None
-            return None
-
-        indexing = {}
-        if self._slicing is not None:
-            indexing = {
-                k: slice(*v)
-                for k, v in self._slicing.items()
-                if k in [self.x, self.y, self.z]
-            }
-
-        if self._time is not None:
-            indexing.update(**{self._time: self.time_index})
-
-        if self.z and self.z_index is not None:
-            indexing.update(**{self.z: self.z_index})
-
-        da = self.data_array.isel(indexing)
-
-        if self._slicing is None and self._resolution is not None:
-            rx, ry, rz = self.resolution_to_sampling_rate(da)
-            if da.ndim <= 1:
-                da = da[::rx]
-            elif da.ndim == 2:
-                da = da[::rx, ::ry]
-            elif da.ndim == 3:
-                da = da[::rx, ::ry, ::rz]
-
-        self._sliced_data_array = da
-        return self._sliced_data_array
-
-    def _compute_mesh(self):
-        self._mesh = self.persisted_data.pyvista.mesh(
-            x=self._x,
-            y=self._y,
-            z=self._z if self._z_index is None else None,
-            order=self._order,
-            component=self._component,
-            mesh_type=self._mesh_type,
-            scales={k: v[2] for k, v in self._slicing.items()} if self._slicing else {},
-        )
-        return self._mesh
-
-    def Modified(self, **kwargs):
-        self._sliced_data_array = None
-        self._persisted_data = None
-        self._mesh = None
-        super().Modified(**kwargs)
-
-    def RequestData(self, request, inInfo, outInfo):
-        # Use open data_array handle to fetch data at
-        # desired Level of Detail
-        try:
-            pdo = self.GetOutputData(outInfo, 0)
-            pdo.ShallowCopy(self.mesh)
-        except Exception as e:
-            traceback.print_exc()
-            raise e
-        return 1
diff --git a/pan3d/xarray/accessor.py b/pan3d/xarray/accessor.py
index 9b84657..db3d93f 100644
--- a/pan3d/xarray/accessor.py
+++ b/pan3d/xarray/accessor.py
@@ -1,10 +1,10 @@
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 import numpy as np
 import xarray as xr
 
 from vtkmodules.vtkCommonDataModel import vtkDataSet
-from pan3d.xarray import datasets
+from pan3d.xarray import datasets, algorithm
 
 # from pvxarray.vtk_source import PyVistaXarraySource
 
@@ -74,25 +74,21 @@ def dataset(
             self, x=x, y=y, z=z, order=order, component=component, scales=scales
         )
 
-    # def algorithm(
-    #     self,
-    #     x: Optional[str] = None,
-    #     y: Optional[str] = None,
-    #     z: Optional[str] = None,
-    #     time: Optional[str] = None,
-    #     order: str = "C",
-    #     component: Optional[str] = None,
-    #     mesh_type: Optional[str] = None,
-    #     resolution: float = 1.0,
-    # ):
-    #     return PyVistaXarraySource(
-    #         data_array=self._xarray,
-    #         x=x,
-    #         y=y,
-    #         z=z,
-    #         time=time,
-    #         order=order,
-    #         component=component,
-    #         mesh_type=mesh_type,
-    #         resolution=resolution,
-    #     )
+    def algorithm(
+        self,
+        x: Optional[str] = None,
+        y: Optional[str] = None,
+        z: Optional[str] = None,
+        t: Optional[str] = None,
+        arrays: Optional[List[str]] = None,
+        order: str = "C",
+    ):
+        return algorithm.vtkXArrayRectilinearSource(
+            input=self._xarray,
+            x=x,
+            y=y,
+            z=z,
+            t=t,
+            arrays=arrays,
+            order=order,
+        )
diff --git a/pan3d/xarray/algorithm.py b/pan3d/xarray/algorithm.py
index cb92f5e..0f31401 100644
--- a/pan3d/xarray/algorithm.py
+++ b/pan3d/xarray/algorithm.py
@@ -1,11 +1,43 @@
 import traceback
 from typing import List, Optional
 
+import json
 import xarray as xr
 from vtkmodules.vtkCommonDataModel import vtkRectilinearGrid
 from vtkmodules.util.vtkAlgorithm import VTKPythonAlgorithmBase
 from vtkmodules.vtkFiltersCore import vtkArrayCalculator
 
+# -----------------------------------------------------------------------------
+# Helper functions
+# -----------------------------------------------------------------------------
+
+
+def slice_array(array, slice_info):
+    if slice_info is None:
+        return array
+    if isinstance(slice_info, int):
+        return array[slice_info]
+    return array[slice(*slice_info)]
+
+
+def to_isel(slices_info, *array_names):
+    slices = {}
+    for name in array_names:
+        info = slices_info.get(name)
+        if info is None:
+            continue
+        if isinstance(info, int):
+            slices[name] = info
+        else:
+            slices[name] = slice(*info)
+
+    return slices if slices else None
+
+
+# -----------------------------------------------------------------------------
+# VTK Algorithms
+# -----------------------------------------------------------------------------
+
 
 class vtkXArrayRectilinearSource(VTKPythonAlgorithmBase):
     def __init__(
@@ -51,6 +83,19 @@ def __init__(
         if len(self._array_names) == 0:
             self.arrays = self.available_arrays
 
+    def __str__(self):
+        return f"""
+x: {self.x}
+y: {self.y}
+z: {self.z}
+t: {self.t} ({self.t_index + 1}/{self.t_size})
+arrays: {self.arrays}
+        {self.available_arrays}
+slicing: {json.dumps(self.slicing, indent=2)}
+computed: {json.dumps(self.computed, indent=2)}
+order: {self._order}
+"""
+
     # -------------------------------------------------------------------------
     # Data input
     # -------------------------------------------------------------------------
@@ -176,8 +221,10 @@ def apply_coords(self):
         self.t = None
 
         # assign mapping
-        for key, value in zip(["x", "y", "z", "t"], coords):
-            # print(f"set({key}={value})")
+        axes = ["t", "z", "y", "x"]
+        while len(axes) > len(coords):
+            axes.pop(0)
+        for key, value in zip(axes, coords):
             setattr(self, key, value)
 
     @property
@@ -228,6 +275,20 @@ def available_arrays(self):
 
         return list(set(self._input.variables.keys()) - set(self._input.coords.keys()))
 
+    @property
+    def slicing(self):
+        result = dict(self._slices or {})
+        if self.t is not None:
+            result[self.t] = self.t_index
+        return result
+
+    @slicing.setter
+    def slicing(self, v):
+        if v != self._slices:
+            self._slices = v
+            self._xarray_mesh = None
+            self.Modified()
+
     # -------------------------------------------------------------------------
     # properties
     # -------------------------------------------------------------------------
@@ -251,18 +312,27 @@ def computed(self, v):
         if self._computed != v:
             self._computed = v or {}
             self._pipeline = None
+            scalar_arrays = self._computed.get("_use_scalars", [])
+            vector_arrays = self._computed.get("_use_vectors", [])
 
             for output_name, func in self._computed.items():
+                if output_name[0] == "_":
+                    continue
+                filter = vtkArrayCalculator(
+                    result_array_name=output_name,
+                    function=func,
+                )
+
+                # register array dependencies
+                for scalar_array in scalar_arrays:
+                    filter.AddScalarArrayName(scalar_array)
+                for vector_array in vector_arrays:
+                    filter.AddVectorArrayName(vector_array)
+
                 if self._pipeline is None:
-                    self._pipeline = vtkArrayCalculator(
-                        result_array_name=output_name,
-                        function=func,
-                    )
+                    self._pipeline = filter
                 else:
-                    self._pipeline = self._pipeline >> vtkArrayCalculator(
-                        result_array_name=output_name,
-                        function=func,
-                    )
+                    self._pipeline = self._pipeline >> filter
 
             self.Modified()
 
@@ -280,26 +350,32 @@ def RequestData(self, request, inInfo, outInfo):
             if self._xarray_mesh is None:
                 # grid
                 mesh = vtkRectilinearGrid()
-                mesh.x_coordinates = self._input[self._x].values
-                mesh.y_coordinates = self._input[self._y].values
-                mesh.z_coordinates = self._input[self._z].values
+                mesh.x_coordinates = slice_array(
+                    self._input[self._x].values, self.slicing.get(self._x)
+                )
+                mesh.y_coordinates = slice_array(
+                    self._input[self._y].values, self.slicing.get(self._y)
+                )
+                mesh.z_coordinates = slice_array(
+                    self._input[self._z].values, self.slicing.get(self._z)
+                )
                 mesh.dimensions = [
                     mesh.x_coordinates.size,
                     mesh.y_coordinates.size,
                     mesh.z_coordinates.size,
                 ]
                 # fields
+                indexing = to_isel(self.slicing, self.x, self.y, self.z, self.t)
                 for field_name in self._array_names:
                     da = self._input[field_name]
-                    if self.t is not None:
-                        da = da.isel({self._t: self._t_index})
+                    if indexing is not None:
+                        da = da.isel(indexing)
                     mesh.point_data[field_name] = da.values.ravel(order=self._order)
 
                 self._xarray_mesh = mesh
 
             # Compute derived quantity
             if self._pipeline is not None:
-                print(self._pipeline)
                 pdo.ShallowCopy(self._pipeline(self._xarray_mesh))
             else:
                 pdo.ShallowCopy(self._xarray_mesh)