Repository: dcs4cop/xcube
Pull request #261 (2020-01-16 08:59:06)

Forman 206 optim rectify


Patch:
diff --git a/examples/notebooks/read_grib.ipynb b/examples/notebooks/read_grib.ipynb
deleted file mode 100644
index a13c66b1..00000000
--- a/examples/notebooks/read_grib.ipynb
+++ /dev/null
@@ -1,368 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Reading ECMWF data in gribs format\n",
-    "\n",
-    "## Pre-requisites\n",
-    "- CDS Client is installed via conda and user id and key are valid\n",
-    "- xarray, eccodes, and cfgrib are installed in conda env "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Retrieve data from ECMWF MARS archive"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import cdsapi\n",
-    "\n",
-    "c = cdsapi.Client()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2020-01-15 17:38:02,738 INFO Sending request to https://cds.climate.copernicus.eu/api/v2/resources/reanalysis-era5-single-levels\n",
-      "2020-01-15 17:38:03,036 INFO Request is queued\n",
-      "2020-01-15 17:38:04,091 INFO Request is running\n",
-      "2020-01-15 17:38:11,380 INFO Request is completed\n",
-      "2020-01-15 17:38:11,380 INFO Downloading http://136.156.132.110/cache-compute-0001/cache/data9/adaptor.mars.internal-1579106283.8207743-9085-18-d2201176-5a2b-49a2-95d7-75c682272c6d.grib to download.grib (120.8M)\n",
-      "2020-01-15 17:39:49,421 INFO Download rate 1.2M/s                                                                                                                           \n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "Result(content_length=126672600,content_type=application/x-grib,location=http://136.156.132.110/cache-compute-0001/cache/data9/adaptor.mars.internal-1579106283.8207743-9085-18-d2201176-5a2b-49a2-95d7-75c682272c6d.grib)"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import cdsapi\n",
-    "\n",
-    "c = cdsapi.Client()\n",
-    "\n",
-    "c.retrieve(\n",
-    "    'reanalysis-era5-single-levels',\n",
-    "    {\n",
-    "        'product_type': 'reanalysis',\n",
-    "        'format': 'grib',\n",
-    "        'year': '2019',\n",
-    "        'day': [\n",
-    "            '01', '02', '03',\n",
-    "            '04', '05', '06',\n",
-    "            '07', '08', '09',\n",
-    "            '10', '11', '12',\n",
-    "            '13', '14', '15',\n",
-    "            '16', '17', '18',\n",
-    "            '19', '20', '21',\n",
-    "            '22', '23', '24',\n",
-    "            '25', '26', '27',\n",
-    "            '28', '29', '30',\n",
-    "            '31',\n",
-    "        ],\n",
-    "        'month': [\n",
-    "            '05', '06',\n",
-    "        ],\n",
-    "        'time': '13:00',\n",
-    "        'variable': '2m_temperature',\n",
-    "    },\n",
-    "    'download.grib')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Read downloaded file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Ignoring index file 'C:\\\\Users\\\\gunnar\\\\src\\\\data\\\\ecmwf\\\\download.grib.4cc40.idx' older than GRIB file\n"
-     ]
-    }
-   ],
-   "source": [
-    "ds = xr.open_dataset('download.grib', engine='cfgrib')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<pre>&lt;xarray.Dataset&gt;\n",
-       "Dimensions:     (latitude: 721, longitude: 1440, time: 61)\n",
-       "Coordinates:\n",
-       "    number      int32 ...\n",
-       "  * time        (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "    step        timedelta64[ns] ...\n",
-       "    surface     int32 ...\n",
-       "  * latitude    (latitude) float64 90.0 89.75 89.5 89.25 ... -89.5 -89.75 -90.0\n",
-       "  * longitude   (longitude) float64 0.0 0.25 0.5 0.75 ... 359.2 359.5 359.8\n",
-       "    valid_time  (time) datetime64[ns] ...\n",
-       "Data variables:\n",
-       "    t2m         (time, latitude, longitude) float32 ...\n",
-       "Attributes:\n",
-       "    GRIB_edition:            1\n",
-       "    GRIB_centre:             ecmf\n",
-       "    GRIB_centreDescription:  European Centre for Medium-Range Weather Forecasts\n",
-       "    GRIB_subCentre:          0\n",
-       "    Conventions:             CF-1.7\n",
-       "    institution:             European Centre for Medium-Range Weather Forecasts\n",
-       "    history:                 2020-01-15T22:48:18 GRIB to CDM+CF via cfgrib-0....</pre>"
-      ],
-      "text/plain": [
-       "<xarray.Dataset>\n",
-       "Dimensions:     (latitude: 721, longitude: 1440, time: 61)\n",
-       "Coordinates:\n",
-       "    number      int32 ...\n",
-       "  * time        (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "    step        timedelta64[ns] ...\n",
-       "    surface     int32 ...\n",
-       "  * latitude    (latitude) float64 90.0 89.75 89.5 89.25 ... -89.5 -89.75 -90.0\n",
-       "  * longitude   (longitude) float64 0.0 0.25 0.5 0.75 ... 359.2 359.5 359.8\n",
-       "    valid_time  (time) datetime64[ns] ...\n",
-       "Data variables:\n",
-       "    t2m         (time, latitude, longitude) float32 ...\n",
-       "Attributes:\n",
-       "    GRIB_edition:            1\n",
-       "    GRIB_centre:             ecmf\n",
-       "    GRIB_centreDescription:  European Centre for Medium-Range Weather Forecasts\n",
-       "    GRIB_subCentre:          0\n",
-       "    Conventions:             CF-1.7\n",
-       "    institution:             European Centre for Medium-Range Weather Forecasts\n",
-       "    history:                 2020-01-15T22:48:18 GRIB to CDM+CF via cfgrib-0...."
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.QuadMesh at 0x1c909b364c8>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "ds.t2m.isel(time=0).plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# xcube imports\n",
-    "from xcube.core.compute import compute_cube\n",
-    "from xcube.core.maskset import MaskSet\n",
-    "from xcube.core.geom import mask_dataset_by_geometry\n",
-    "from xcube.core.geom import clip_dataset_by_geometry"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "aoi = dict(type='Polygon', coordinates=[[[0.,30.],[0.,90.],[60.,90],[60.,0.],[0.,30]]] )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "masked_ds = mask_dataset_by_geometry(ds,aoi)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<pre>&lt;xarray.Dataset&gt;\n",
-       "Dimensions:     (latitude: 360, longitude: 241, time: 61)\n",
-       "Coordinates:\n",
-       "    number      int32 0\n",
-       "  * time        (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "    step        timedelta64[ns] 00:00:00\n",
-       "    surface     int32 0\n",
-       "  * latitude    (latitude) float64 90.0 89.75 89.5 89.25 ... 1.0 0.75 0.5 0.25\n",
-       "  * longitude   (longitude) float64 0.0 0.25 0.5 0.75 ... 59.25 59.5 59.75 60.0\n",
-       "    valid_time  (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "Data variables:\n",
-       "    t2m         (time, latitude, longitude) float32 261.65878 ... 299.716\n",
-       "Attributes:\n",
-       "    GRIB_edition:            1\n",
-       "    GRIB_centre:             ecmf\n",
-       "    GRIB_centreDescription:  European Centre for Medium-Range Weather Forecasts\n",
-       "    GRIB_subCentre:          0\n",
-       "    Conventions:             CF-1.7\n",
-       "    institution:             European Centre for Medium-Range Weather Forecasts\n",
-       "    history:                 2020-01-15T22:48:18 GRIB to CDM+CF via cfgrib-0....\n",
-       "    geospatial_lon_units:    degrees_east\n",
-       "    geospatial_lat_units:    degrees_north\n",
-       "    date_modified:           2020-01-15T22:48:24.025804</pre>"
-      ],
-      "text/plain": [
-       "<xarray.Dataset>\n",
-       "Dimensions:     (latitude: 360, longitude: 241, time: 61)\n",
-       "Coordinates:\n",
-       "    number      int32 0\n",
-       "  * time        (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "    step        timedelta64[ns] 00:00:00\n",
-       "    surface     int32 0\n",
-       "  * latitude    (latitude) float64 90.0 89.75 89.5 89.25 ... 1.0 0.75 0.5 0.25\n",
-       "  * longitude   (longitude) float64 0.0 0.25 0.5 0.75 ... 59.25 59.5 59.75 60.0\n",
-       "    valid_time  (time) datetime64[ns] 2019-05-01T13:00:00 ... 2019-06-30T13:00:00\n",
-       "Data variables:\n",
-       "    t2m         (time, latitude, longitude) float32 261.65878 ... 299.716\n",
-       "Attributes:\n",
-       "    GRIB_edition:            1\n",
-       "    GRIB_centre:             ecmf\n",
-       "    GRIB_centreDescription:  European Centre for Medium-Range Weather Forecasts\n",
-       "    GRIB_subCentre:          0\n",
-       "    Conventions:             CF-1.7\n",
-       "    institution:             European Centre for Medium-Range Weather Forecasts\n",
-       "    history:                 2020-01-15T22:48:18 GRIB to CDM+CF via cfgrib-0....\n",
-       "    geospatial_lon_units:    degrees_east\n",
-       "    geospatial_lat_units:    degrees_north\n",
-       "    date_modified:           2020-01-15T22:48:24.025804"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "masked_ds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<xarray.backends.zarr.ZarrStore at 0x1c90cb41b28>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "masked_ds.to_zarr('t2m_v1.zarr')"
-   ]
-  },
-  {
-   "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.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/xcube/core/geocoding.py b/xcube/core/geocoding.py
index 98e85b97..b361d354 100644
--- a/xcube/core/geocoding.py
+++ b/xcube/core/geocoding.py
@@ -286,8 +286,8 @@ def compute_ij_bboxes(x_image: np.ndarray,
         y_min = xy_bbox[1] - xy_border
         x_max = xy_bbox[2] + xy_border
         y_max = xy_bbox[3] + xy_border
-        for j in nb.prange(h):
-            for i in nb.prange(w):
+        for j in range(h):
+            for i in range(w):
                 x = x_image[j, i]
                 if x_min <= x <= x_max:
                     y = y_image[j, i]
diff --git a/xcube/core/rectify.py b/xcube/core/rectify.py
index c8aeb5dc..93ee5bae 100644
--- a/xcube/core/rectify.py
+++ b/xcube/core/rectify.py
@@ -18,7 +18,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
-
+import math
 from typing import Mapping, Optional, Sequence, Tuple, Union
 
 import dask.array as da
@@ -39,8 +39,8 @@ def rectify_dataset(dataset: xr.Dataset,
                     output_geom: ImageGeom = None,
                     is_y_axis_inverted: bool = False,
                     tile_size: Union[int, Tuple[int, int]] = None,
-                    compute_xy: bool = False,
-                    compute_vars: bool = False,
+                    load_xy: bool = False,
+                    load_vars: bool = False,
                     compute_subset: bool = True,
                     uv_delta: float = 1e-3) -> Optional[xr.Dataset]:
     """
@@ -67,9 +67,9 @@ def rectify_dataset(dataset: xr.Dataset,
         to spatially fit *dataset* and to retain its spatial resolution.
     :param is_y_axis_inverted: Whether the y-axis labels in the output should be in inverse order.
     :param tile_size: Optional tile size for the output.
-    :param compute_xy: Compute x,y coordinates and load into memory before the actual rectification process.
+    :param load_xy: Compute x,y coordinates and load into memory before the actual rectification process.
         May improve runtime performance at the cost of higher memory consumption.
-    :param compute_vars: Compute source variables and load into memory before the actual rectification process.
+    :param load_vars: Compute source variables and load into memory before the actual rectification process.
         May improve runtime performance at the cost of higher memory consumption.
     :param uv_delta: A normalized value that is used to determine whether x,y coordinates in the output are contained
         in the triangles defined by the input x,y coordinates.
@@ -100,17 +100,23 @@ def rectify_dataset(dataset: xr.Dataset,
 
     src_vars = select_variables(dataset, var_names, geo_coding=src_geo_coding)
 
-    if compute_xy:
+    if load_xy:
         # This is NOT faster:
         src_x = src_x.compute()
         src_y = src_y.compute()
         src_geo_coding = src_geo_coding.derive(x=src_x, y=src_y)
 
-    is_output_tiled = output_geom.is_tiled
-    if not is_output_tiled:
-        get_dst_var_array = _get_dst_var_array_numpy
-    else:
+    if output_geom.is_tiled:
+        get_dst_src_ij_array = _get_dst_src_ij_array_dask
         get_dst_var_array = _get_dst_var_array_dask
+    else:
+        get_dst_src_ij_array = _get_dst_src_ij_array_numpy
+        get_dst_var_array = _get_dst_var_array_numpy
+
+    dst_src_ij_array = get_dst_src_ij_array(src_geo_coding,
+                                            output_geom,
+                                            is_y_axis_inverted,
+                                            uv_delta)
 
     dst_dims = src_geo_coding.xy_names[::-1]
     dst_ds_coords = output_geom.coord_vars(xy_names=src_geo_coding.xy_names,
@@ -118,7 +124,7 @@ def rectify_dataset(dataset: xr.Dataset,
                                            is_y_axis_inverted=is_y_axis_inverted)
     dst_vars = dict()
     for src_var_name, src_var in src_vars.items():
-        if compute_vars:
+        if load_vars:
             # This is NOT faster:
             src_var = src_var.compute()
 
@@ -126,10 +132,8 @@ def rectify_dataset(dataset: xr.Dataset,
         dst_var_coords = {d: src_var.coords[d] for d in dst_var_dims if d in src_var.coords}
         dst_var_coords.update({d: dst_ds_coords[d] for d in dst_var_dims if d in dst_ds_coords})
         dst_var_array = get_dst_var_array(src_var,
-                                          src_geo_coding,
-                                          output_geom,
-                                          is_y_axis_inverted,
-                                          uv_delta)
+                                          dst_src_ij_array,
+                                          fill_value=np.nan)
         dst_var = xr.DataArray(dst_var_array,
                                dims=dst_var_dims,
                                coords=dst_var_coords,
@@ -138,42 +142,41 @@ def rectify_dataset(dataset: xr.Dataset,
     return xr.Dataset(dst_vars, coords=dst_ds_coords, attrs=src_attrs)
 
 
-def _get_dst_var_array_numpy(src_var: xr.DataArray,
-                             src_geo_coding: GeoCoding,
-                             output_geom: ImageGeom,
-                             is_dst_y_axis_inverted: bool,
-                             uv_delta: float) -> np.ndarray:
+def _get_dst_src_ij_array_numpy(src_geo_coding: GeoCoding,
+                                output_geom: ImageGeom,
+                                is_dst_y_axis_inverted: bool,
+                                uv_delta: float) -> np.ndarray:
     dst_width = output_geom.width
     dst_height = output_geom.height
-    dst_var_shape = src_var.shape[0:-2] + (dst_height, dst_width)
-    dst_var_array = np.full(dst_var_shape, np.nan, dtype=src_var.dtype)
+    dst_shape = 2, dst_height, dst_width
+    dst_src_ij_values = np.full(dst_shape, np.nan, dtype=np.float64)
     dst_x_min = output_geom.x_min
     dst_y_min = output_geom.y_min
     dst_xy_res = output_geom.xy_res
-    _reproject(src_var.values,
-               src_geo_coding.x.values,
-               src_geo_coding.y.values,
-               dst_var_array,
-               dst_x_min,
-               dst_y_min,
-               dst_xy_res,
-               uv_delta=uv_delta)
+    _compute_source_pixels(src_geo_coding.x.values,
+                           src_geo_coding.y.values,
+                           0,
+                           0,
+                           dst_src_ij_values,
+                           dst_x_min,
+                           dst_y_min,
+                           dst_xy_res,
+                           uv_delta=uv_delta)
     if is_dst_y_axis_inverted:
-        dst_var_array = dst_var_array[..., ::-1, :]
-    return dst_var_array
+        dst_src_ij_values = dst_src_ij_values[:, ::-1, :]
+    return dst_src_ij_values
 
 
-def _get_dst_var_array_dask(src_var: xr.DataArray,
-                            src_geo_coding: GeoCoding,
-                            output_geom: ImageGeom,
-                            is_dst_y_axis_inverted: bool,
-                            uv_delta: float) -> da.Array:
+def _get_dst_src_ij_array_dask(src_geo_coding: GeoCoding,
+                               output_geom: ImageGeom,
+                               is_dst_y_axis_inverted: bool,
+                               uv_delta: float) -> da.Array:
     dst_width = output_geom.width
     dst_height = output_geom.height
     dst_tile_width = output_geom.tile_width
     dst_tile_height = output_geom.tile_height
-    dst_var_shape = src_var.shape[0:-2] + (dst_height, dst_width)
-    dst_var_chunks = src_var.shape[0:-2] + (dst_tile_height, dst_tile_width)
+    dst_var_shape = 2, dst_height, dst_width
+    dst_var_chunks = 2, dst_tile_height, dst_tile_width
 
     dst_x_min = output_geom.x_min
     dst_y_min = output_geom.y_min
@@ -182,10 +185,10 @@ def _get_dst_var_array_dask(src_var: xr.DataArray,
     dst_xy_bboxes = output_geom.xy_bboxes
     src_ij_bboxes = src_geo_coding.ij_bboxes(dst_xy_bboxes, xy_border=dst_xy_res, ij_border=1)
 
-    return compute_array_from_func(_rectify_func_dask,
+    return compute_array_from_func(_compute_source_pixels_block,
                                    dst_var_shape,
                                    dst_var_chunks,
-                                   src_var.dtype,
+                                   np.float64,
                                    ctx_arg_names=[
                                        'dtype',
                                        'block_id',
@@ -193,7 +196,6 @@ def _get_dst_var_array_dask(src_var: xr.DataArray,
                                        'block_slices',
                                    ],
                                    args=(
-                                       src_var,
                                        src_geo_coding.x,
                                        src_geo_coding.y,
                                        src_ij_bboxes,
@@ -203,43 +205,73 @@ def _get_dst_var_array_dask(src_var: xr.DataArray,
                                        is_dst_y_axis_inverted,
                                        uv_delta
                                    ),
-                                   name=src_var.name,
+                                   name='ij_pixels',
                                    )
 
 
-def _rectify_func_dask(array_dtype: np.dtype,
-                       block_id: int,
-                       block_shape: Tuple[int, int],
-                       block_slices: Tuple[Tuple[int, int], Tuple[int, int]],
-                       src_var: xr.DataArray,
-                       src_x: xr.DataArray,
-                       src_y: xr.DataArray,
-                       src_ij_bboxes: np.ndarray,
-                       dst_x_min: float,
-                       dst_y_min: float,
-                       dst_xy_res: float,
-                       is_dst_y_axis_inverted: bool,
-                       uv_delta: float) -> np.ndarray:
-    dst_block = np.full(src_var.shape[:-2] + block_shape, np.nan, dtype=array_dtype)
-    (dst_y_slice_start, _), (dst_x_slice_start, _) = block_slices
+def _get_dst_var_array_numpy(src_var: xr.DataArray,
+                             dst_src_ij_array: np.ndarray,
+                             fill_value: Union[int, float, complex] = np.nan) -> np.ndarray:
+    return _get_dst_var_array_numpy_numba(src_var.values, dst_src_ij_array, fill_value)
+
+
+@nb.njit(nogil=True, cache=True)
+def _get_dst_var_array_numpy_numba(src_var: np.ndarray,
+                                   dst_src_ij_array: np.ndarray,
+                                   fill_value: Union[int, float, complex] = np.nan) -> np.ndarray:
+    dst_width = dst_src_ij_array.shape[-1]
+    dst_height = dst_src_ij_array.shape[-2]
+    dst_shape = src_var.shape[:-2] + (dst_height, dst_width)
+    dst_values = np.full(dst_shape, fill_value, dtype=src_var.dtype)
+    _extract_source_pixels(src_var,
+                           dst_src_ij_array,
+                           dst_values)
+    return dst_values
+
+
+def _get_dst_var_array_dask(src_var: xr.DataArray,
+                            dst_src_ij_array: np.ndarray,
+                            fill_value: Union[int, float, complex] = np.nan) -> da.Array:
+    return da.map_blocks(_get_dst_var_array_numpy_numba,
+                         src_var.values,
+                         dst_src_ij_array,
+                         fill_value,
+                         dtype=src_var.dtype,
+                         drop_axis=0)
+
+
+def _compute_source_pixels_block(dtype: np.dtype,
+                                 block_id: int,
+                                 block_shape: Tuple[int, int],
+                                 block_slices: Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]],
+                                 src_x: xr.DataArray,
+                                 src_y: xr.DataArray,
+                                 src_ij_bboxes: np.ndarray,
+                                 dst_x_min: float,
+                                 dst_y_min: float,
+                                 dst_xy_res: float,
+                                 is_dst_y_axis_inverted: bool,
+                                 uv_delta: float) -> np.ndarray:
+    dst_src_ij_block = np.full(block_shape, np.nan, dtype=dtype)
+    _, (dst_y_slice_start, _), (dst_x_slice_start, _) = block_slices
     src_ij_bbox = src_ij_bboxes[block_id]
     src_i_min, src_j_min, src_i_max, src_j_max = src_ij_bbox
     if src_i_min == -1:
-        return dst_block
-    src_var_values = src_var[..., src_j_min:src_j_max + 1, src_i_min:src_i_max + 1].values
+        return dst_src_ij_block
     src_x_values = src_x[src_j_min:src_j_max + 1, src_i_min:src_i_max + 1].values
     src_y_values = src_y[src_j_min:src_j_max + 1, src_i_min:src_i_max + 1].values
-    _reproject(src_var_values,
-               src_x_values,
-               src_y_values,
-               dst_block,
-               dst_x_min + dst_x_slice_start * dst_xy_res,
-               dst_y_min + dst_y_slice_start * dst_xy_res,
-               dst_xy_res,
-               uv_delta)
+    _compute_source_pixels(src_x_values,
+                           src_y_values,
+                           src_i_min,
+                           src_j_min,
+                           dst_src_ij_block,
+                           dst_x_min + dst_x_slice_start * dst_xy_res,
+                           dst_y_min + dst_y_slice_start * dst_xy_res,
+                           dst_xy_res,
+                           uv_delta)
     if is_dst_y_axis_inverted:
-        dst_block = dst_block[..., ::-1, :]
-    return dst_block
+        dst_src_ij_block = dst_src_ij_block[:, ::-1, :]
+    return dst_src_ij_block
 
 
 def select_variables(dataset,
@@ -280,153 +312,29 @@ def _is_2d_var(var: xr.DataArray, two_d_coord_var: xr.DataArray) -> bool:
     return var.ndim >= 2 and var.shape[-2:] == two_d_coord_var.shape and var.dims[-2:] == two_d_coord_var.dims
 
 
-@nb.jit('float64(float64, float64, float64, float64, float64, float64)',
-        nopython=True, nogil=True, inline='always')
-def _fdet(px0: float, py0: float, px1: float, py1: float, px2: float, py2: float) -> float:
-    return (px0 - px1) * (py0 - py2) - (px0 - px2) * (py0 - py1)
-
-
-@nb.jit('float64(float64, float64, float64, float64, float64, float64)',
-        nopython=True, nogil=True, inline='always')
-def _fu(px: float, py: float, px0: float, py0: float, px2: float, py2: float) -> float:
-    return (px0 - px) * (py0 - py2) - (py0 - py) * (px0 - px2)
-
-
-@nb.jit('float64(float64, float64, float64, float64, float64, float64)',
-        nopython=True, nogil=True, inline='always')
-def _fv(px: float, py: float, px0: float, py0: float, px1: float, py1: float) -> float:
-    return (py0 - py) * (px0 - px1) - (px0 - px) * (py0 - py1)
-
-
-@nb.jit(nopython=True, nogil=True, cache=True)
-def _reproject(src_values: np.ndarray,
-               src_x: np.ndarray,
-               src_y: np.ndarray,
-               dst_values: np.ndarray,
-               dst_x0: float,
-               dst_y0: float,
-               dst_res: float,
-               uv_delta: float):
-    src_width = src_values.shape[-1]
-    src_height = src_values.shape[-2]
-
-    dst_width = dst_values.shape[-1]
-    dst_height = dst_values.shape[-2]
-
-    dst_px = np.zeros(4, dtype=src_x.dtype)
-    dst_py = np.zeros(4, dtype=src_y.dtype)
-
-    u_min = v_min = -uv_delta
-    uv_max = 1.0 + 2 * uv_delta
-
-    dst_values[..., :, :] = np.nan
-
-    for src_j0 in range(src_height - 1):
-        for src_i0 in range(src_width - 1):
-            src_i1 = src_i0 + 1
-            src_j1 = src_j0 + 1
-
-            dst_px[0] = dst_p0x = src_x[src_j0, src_i0]
-            dst_px[1] = dst_p1x = src_x[src_j0, src_i1]
-            dst_px[2] = dst_p2x = src_x[src_j1, src_i0]
-            dst_px[3] = dst_p3x = src_x[src_j1, src_i1]
-
-            dst_py[0] = dst_p0y = src_y[src_j0, src_i0]
-            dst_py[1] = dst_p1y = src_y[src_j0, src_i1]
-            dst_py[2] = dst_p2y = src_y[src_j1, src_i0]
-            dst_py[3] = dst_p3y = src_y[src_j1, src_i1]
-
-            dst_pi = np.floor((dst_px - dst_x0) / dst_res).astype(np.int64)
-            dst_pj = np.floor((dst_py - dst_y0) / dst_res).astype(np.int64)
-
-            dst_i_min = np.min(dst_pi)
-            dst_i_max = np.max(dst_pi)
-            dst_j_min = np.min(dst_pj)
-            dst_j_max = np.max(dst_pj)
-
-            if dst_i_max < 0 \
-                    or dst_j_max < 0 \
-                    or dst_i_min >= dst_width \
-                    or dst_j_min >= dst_height:
-                continue
-
-            if dst_i_min < 0:
-                dst_i_min = 0
-
-            if dst_i_max >= dst_width:
-                dst_i_max = dst_width - 1
-
-            if dst_j_min < 0:
-                dst_j_min = 0
-
-            if dst_j_max >= dst_height:
-                dst_j_max = dst_height - 1
-
-            # u from p0 right to p1, v from p0 down to p2
-            det_a = _fdet(dst_p0x, dst_p0y, dst_p1x, dst_p1y, dst_p2x, dst_p2y)
-            # u from p3 left to p2, v from p3 up to p1
-            det_b = _fdet(dst_p3x, dst_p3y, dst_p2x, dst_p2y, dst_p1x, dst_p1y)
-
-            if np.isnan(det_a) or np.isnan(det_b):
-                # print('no plane at:', src_i0, src_j0)
-                continue
-
-            for dst_j in range(dst_j_min, dst_j_max + 1):
-                dst_y = dst_y0 + (dst_j + 0.5) * dst_res
-                for dst_i in range(dst_i_min, dst_i_max + 1):
-                    dst_x = dst_x0 + (dst_i + 0.5) * dst_res
-
-                    # TODO: use two other combinations,
-                    #       if one of the dst_px<n>,dst_py<n> pairs is missing.
-
-                    if not np.isnan(dst_values[..., dst_j, dst_i]):
-                        # print('already set:', src_i0, src_j0, '-->', dst_i, dst_j)
-                        continue
-
-                    src_i = -1
-                    src_j = -1
-                    if det_a != 0.0:
-                        u = _fu(dst_x, dst_y, dst_p0x, dst_p0y, dst_p2x, dst_p2y) / det_a
-                        v = _fv(dst_x, dst_y, dst_p0x, dst_p0y, dst_p1x, dst_p1y) / det_a
-                        if u >= u_min and v >= v_min and u + v <= uv_max:
-                            src_i = src_i0 if u < 0.5 else src_i1
-                            src_j = src_j0 if v < 0.5 else src_j1
-                    if src_i == -1 and det_b != 0.0:
-                        u = _fu(dst_x, dst_y, dst_p3x, dst_p3y, dst_p1x, dst_p1y) / det_b
-                        v = _fv(dst_x, dst_y, dst_p3x, dst_p3y, dst_p2x, dst_p2y) / det_b
-                        if u >= u_min and v >= v_min and u + v <= uv_max:
-                            src_i = src_i1 if u < 0.5 else src_i0
-                            src_j = src_j1 if v < 0.5 else src_j0
-                    if src_i != -1:
-                        dst_values[..., dst_j, dst_i] = src_values[..., src_j, src_i]
-
-
-@nb.jit(nopython=True, cache=True)
-def compute_source_pixels(src_x: np.ndarray,
-                          src_y: np.ndarray,
-                          src_i_min: int,
-                          src_j_min: int,
-                          dst_src_i: np.ndarray,
-                          dst_src_j: np.ndarray,
-                          dst_x0: float,
-                          dst_y0: float,
-                          dst_res: float,
-                          fractions: bool = False,
-                          delta: float = 1e-3):
+@nb.njit(nogil=True, cache=True)
+def _compute_source_pixels(src_x: np.ndarray,
+                           src_y: np.ndarray,
+                           src_i_min: int,
+                           src_j_min: int,
+                           dst_src_ij: np.ndarray,
+                           dst_x0: float,
+                           dst_y0: float,
+                           dst_res: float,
+                           uv_delta: float = 1e-3):
     src_width = src_x.shape[-1]
     src_height = src_x.shape[-2]
 
-    dst_width = dst_src_i.shape[-1]
-    dst_height = dst_src_i.shape[-2]
+    dst_width = dst_src_ij.shape[-1]
+    dst_height = dst_src_ij.shape[-2]
 
     dst_px = np.zeros(4, dtype=src_x.dtype)
     dst_py = np.zeros(4, dtype=src_y.dtype)
 
-    dst_src_i[:, :] = np.nan
-    dst_src_j[:, :] = np.nan
+    dst_src_ij[:, :, :] = np.nan
 
-    u_min = v_min = -delta
-    uv_max = 1.0 + 2 * delta
+    u_min = v_min = -uv_delta
+    uv_max = 1.0 + 2 * uv_delta
 
     for src_j0 in range(src_height - 1):
         for src_i0 in range(src_width - 1):
@@ -492,63 +400,74 @@ def compute_source_pixels(src_x: np.ndarray,
                         u = _fu(dst_x, dst_y, dst_p0x, dst_p0y, dst_p2x, dst_p2y) / det_a
                         v = _fv(dst_x, dst_y, dst_p0x, dst_p0y, dst_p1x, dst_p1y) / det_a
                         if u >= u_min and v >= v_min and u + v <= uv_max:
-                            if fractions:
-                                src_i = src_i0 + u
-                                src_j = src_j0 + v
-                            else:
-                                src_i = src_i0 if u < 0.5 else src_i1
-                                src_j = src_j0 if v < 0.5 else src_j1
+                            src_i = src_i0 + _fclamp(u, 0.0, 1.0)
+                            src_j = src_j0 + _fclamp(v, 0.0, 1.0)
                     if src_i == -1 and det_b != 0.0:
                         u = _fu(dst_x, dst_y, dst_p3x, dst_p3y, dst_p1x, dst_p1y) / det_b
                         v = _fv(dst_x, dst_y, dst_p3x, dst_p3y, dst_p2x, dst_p2y) / det_b
                         if u >= u_min and v >= v_min and u + v <= uv_max:
-                            if fractions:
-                                src_i = src_i1 - u
-                                src_j = src_j1 - v
-                            else:
-                                src_i = src_i1 if u < 0.5 else src_i0
-                                src_j = src_j1 if v < 0.5 else src_j0
+                            src_i = src_i1 - _fclamp(u, 0.0, 1.0)
+                            src_j = src_j1 - _fclamp(v, 0.0, 1.0)
                     if src_i != -1:
-                        dst_src_i[dst_j, dst_i] = src_i_min + src_i
-                        dst_src_j[dst_j, dst_i] = src_j_min + src_j
+                        dst_src_ij[0, dst_j, dst_i] = src_i_min + src_i
+                        dst_src_ij[1, dst_j, dst_i] = src_j_min + src_j
 
 
-@nb.jit(nopython=True, cache=True)
-def extract_source_pixels(src_values: np.ndarray,
-                          dst_src_i: np.ndarray,
-                          dst_src_j: np.ndarray,
-                          dst_values: np.ndarray,
-                          fill_value: float = np.nan):
+@nb.njit(nogil=True, cache=True)
+def _extract_source_pixels(src_values: np.ndarray,
+                           dst_src_ij: np.ndarray,
+                           dst_values: np.ndarray):
     src_width = src_values.shape[-1]
     src_height = src_values.shape[-2]
 
     dst_width = dst_values.shape[-1]
     dst_height = dst_values.shape[-2]
 
-    # noinspection PyUnusedLocal
-    src_i: int = 0
-    # noinspection PyUnusedLocal
-    src_j: int = 0
+    src_i_min = 0
+    src_j_min = 0
+    src_i_max = src_width - 1
+    src_j_max = src_height - 1
 
     for dst_j in range(dst_height):
         for dst_i in range(dst_width):
-            src_i_f = dst_src_i[dst_j, dst_i]
-            src_j_f = dst_src_j[dst_j, dst_i]
+            src_i_f = dst_src_ij[0, dst_j, dst_i]
+            src_j_f = dst_src_ij[1, dst_j, dst_i]
             if np.isnan(src_i_f) or np.isnan(src_j_f):
-                dst_values[..., dst_j, dst_i] = fill_value
-            else:
-                # TODO: this corresponds to method "nearest": allow for other methods
-                src_i = int(src_i_f + 0.49999)
-                src_j = int(src_j_f + 0.49999)
-                if src_i < 0:
-                    src_i = 0
-                elif src_i >= src_width:
-                    src_i = src_width - 1
-                if src_j < 0:
-                    src_j = 0
-                elif src_j >= src_height:
-                    src_j = src_height - 1
-                dst_values[..., dst_j, dst_i] = src_values[..., src_j, src_i]
+                continue
+            src_i = math.floor(src_i_f + 0.49999)
+            src_j = math.floor(src_j_f + 0.49999)
+            u = src_i_f - src_i
+            v = src_j_f - src_j
+            if u > 0.5:
+                src_i = _iclamp(src_i + 1, src_i_min, src_i_max)
+            if v > 0.5:
+                src_j = _iclamp(src_j + 1, src_j_min, src_j_max)
+            dst_values[..., dst_j, dst_i] = src_values[..., src_j, src_i]
+
+
+@nb.njit('float64(float64, float64, float64, float64, float64, float64)', nogil=True, inline='always')
+def _fdet(px0: float, py0: float, px1: float, py1: float, px2: float, py2: float) -> float:
+    return (px0 - px1) * (py0 - py2) - (px0 - px2) * (py0 - py1)
+
+
+@nb.njit('float64(float64, float64, float64, float64, float64, float64)', nogil=True, inline='always')
+def _fu(px: float, py: float, px0: float, py0: float, px2: float, py2: float) -> float:
+    return (px0 - px) * (py0 - py2) - (py0 - py) * (px0 - px2)
+
+
+@nb.njit('float64(float64, float64, float64, float64, float64, float64)', nogil=True, inline='always')
+def _fv(px: float, py: float, px0: float, py0: float, px1: float, py1: float) -> float:
+    return (py0 - py) * (px0 - px1) - (px0 - px) * (py0 - py1)
+
+
+@nb.njit('float64(float64, float64, float64)', nogil=True, inline='always')
+def _fclamp(x: float, x_min: float, x_max: float) -> float:
+    return x_min if x < x_min else (x_max if x > x_max else x)
+
+
+@nb.njit('int64(int64, int64, int64)', nogil=True, inline='always')
+def _iclamp(x: int, x_min: int, x_max: int) -> int:
+    return x_min if x < x_min else (x_max if x > x_max else x)
 
 
 def _millis(seconds: float) -> int:


Test patch:
diff --git a/test/core/test_rectify.py b/test/core/test_rectify.py
index 2d8aad9c..7d177462 100644
--- a/test/core/test_rectify.py
+++ b/test/core/test_rectify.py
@@ -2,10 +2,12 @@ import unittest
 
 import dask.array as da
 import numpy as np
+# noinspection PyUnresolvedReferences
+import xarray as xr
 
 from xcube.core.rectify import ImageGeom
-from xcube.core.rectify import compute_source_pixels
-from xcube.core.rectify import extract_source_pixels
+from xcube.core.rectify import _compute_source_pixels
+from xcube.core.rectify import _extract_source_pixels
 from xcube.core.rectify import rectify_dataset
 from .test_geocoding import SourceDatasetMixin
 
@@ -20,10 +22,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         dst_ds = rectify_dataset(src_ds)
         lon, lat, rad = self._assert_shape_and_dim(dst_ds, 4, 4)
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([1., 3., 5., 7.],
+                                       np.array([1.0, 3.0, 5., 7.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([51., 53., 55., 57.],
+                                       np.array([51.0, 53.0, 55., 57.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
                                        np.array([
@@ -41,10 +43,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         dst_ds = rectify_dataset(src_ds, output_geom=output_geom)
         lon, lat, rad = self._assert_shape_and_dim(dst_ds, 7, 7)
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([0., 1., 2., 3., 4., 5., 6.],
+                                       np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5., 6.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([50., 51., 52., 53., 54., 55., 56.],
+                                       np.array([50., 51.0, 52.0, 53.0, 54.0, 55., 56.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
                                        np.array([
@@ -65,10 +67,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         dst_ds = rectify_dataset(src_ds, output_geom=output_geom)
         lon, lat, rad = self._assert_shape_and_dim(dst_ds, 7, 7)
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([2., 3., 4., 5., 6., 7., 8.],
+                                       np.array([2.0, 3.0, 4.0, 5., 6., 7., 8.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([51., 52., 53., 54., 55., 56., 57.],
+                                       np.array([51.0, 52.0, 53.0, 54.0, 55., 56., 57.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
                                        np.array([
@@ -89,10 +91,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         dst_ds = rectify_dataset(src_ds, output_geom=output_geom)
         lon, lat, rad = self._assert_shape_and_dim(dst_ds, 13, 13)
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.],
+                                       np.array([0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5., 5.5, 6.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([50., 50.5, 51., 51.5, 52., 52.5, 53., 53.5, 54., 54.5, 55.,
+                                       np.array([50., 50.5, 51.0, 51.5, 52.0, 52.5, 53.0, 53.5, 54.0, 54.5, 55.,
                                                  55.5, 56.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
@@ -102,14 +104,14 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                            [nan, nan, 3.0, 4.0, 4.0, 4.0, 4.0, nan, nan, nan, nan, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 2.0, nan, nan, nan, nan],
                                            [3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 2.0, 2.0, 2.0, nan, nan, nan],
-                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
+                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
                                            [nan, 3.0, 3.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                           [nan, 3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, nan, nan, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
                                        ], dtype=rad.dtype))
 
     def test_rectify_2x2_to_13x13_inverse_y_axis(self):
@@ -120,10 +122,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         dst_ds = rectify_dataset(src_ds, output_geom=output_geom, is_y_axis_inverted=True)
         lon, lat, rad = self._assert_shape_and_dim(dst_ds, 13, 13)
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.],
+                                       np.array([0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5., 5.5, 6.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([56., 55.5, 55., 54.5, 54., 53.5, 53., 52.5, 52., 51.5, 51.,
+                                       np.array([56., 55.5, 55., 54.5, 54.0, 53.5, 53.0, 52.5, 52.0, 51.5, 51.,
                                                  50.5, 50.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
@@ -133,14 +135,14 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                                     [nan, nan, 3.0, 4.0, 4.0, 4.0, 4.0, nan, nan, nan, nan, nan, nan],
                                                     [nan, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 2.0, nan, nan, nan, nan],
                                                     [3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 2.0, 2.0, 2.0, nan, nan, nan],
-                                                    [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
+                                                    [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
                                                     [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
                                                     [nan, 3.0, 3.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                                    [nan, 3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
-                                                    [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, nan, nan, nan, nan, nan],
+                                                    [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
+                                                    [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan],
                                                     [nan, nan, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
                                                     [nan, nan, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                                    [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                                    [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
                                                 ][::-1], dtype=rad.dtype))
 
     def test_rectify_2x2_to_13x13_dask(self):
@@ -155,10 +157,10 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
         self.assertEqual(((7, 6), (7, 6)), rad.chunks)
 
         np.testing.assert_almost_equal(lon.values,
-                                       np.array([0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5., 5.5, 6.],
+                                       np.array([0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5., 5.5, 6.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([50., 50.5, 51., 51.5, 52., 52.5, 53., 53.5, 54., 54.5, 55.,
+                                       np.array([50., 50.5, 51.0, 51.5, 52.0, 52.5, 53.0, 53.5, 54.0, 54.5, 55.,
                                                  55.5, 56.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
@@ -168,14 +170,14 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                            [nan, nan, 3.0, 4.0, 4.0, 4.0, 4.0, nan, nan, nan, nan, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 2.0, nan, nan, nan, nan],
                                            [3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 2.0, 2.0, 2.0, nan, nan, nan],
-                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
+                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
                                            [nan, 3.0, 3.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                           [nan, 3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, nan, nan, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
                                        ], dtype=rad.dtype))
 
     def test_rectify_2x2_to_13x13_antimeridian(self):
@@ -191,7 +193,7 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                                  -178., -177.5, -177., -176.5, -176.],
                                                 dtype=lon.dtype))
         np.testing.assert_almost_equal(lat.values,
-                                       np.array([50., 50.5, 51., 51.5, 52., 52.5, 53., 53.5, 54., 54.5, 55.,
+                                       np.array([50., 50.5, 51.0, 51.5, 52.0, 52.5, 53.0, 53.5, 54.0, 54.5, 55.,
                                                  55.5, 56.],
                                                 dtype=lat.dtype))
         np.testing.assert_almost_equal(rad.values,
@@ -201,14 +203,14 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                            [nan, nan, 3.0, 4.0, 4.0, 4.0, 4.0, nan, nan, nan, nan, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 2.0, nan, nan, nan, nan],
                                            [3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 2.0, 2.0, 2.0, nan, nan, nan],
-                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                           [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.],
+                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
+                                           [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
                                            [nan, 3.0, 3.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                           [nan, 3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, nan, nan, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
                                        ], dtype=rad.dtype))
 
     def test_rectify_2x2_to_13x13_none(self):
@@ -248,61 +250,64 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
 
         return lon, lat, rad
 
-    def test_compute_source_pixels(self):
+    def test_compute_and_extract_source_pixels(self):
         src_ds = self.new_source_dataset()
 
-        dst_src_i = np.full((13, 13), np.nan, dtype=np.float64)
-        dst_src_j = np.full((13, 13), np.nan, dtype=np.float64)
-        compute_source_pixels(src_ds.lon.values,
-                              src_ds.lat.values,
-                              0,
-                              0,
-                              dst_src_i,
-                              dst_src_j,
-                              -0.25,
-                              49.75,
-                              0.5)
-
-        # print(xr.DataArray(src_i, dims=('y', 'x')))
-        # print(xr.DataArray(dst_src_j, dims=('y', 'x')))
-
-        np.testing.assert_almost_equal(np.floor(dst_src_i + 0.5),
-                                       np.array([[nan, nan, nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan],
-                                                 [nan, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan],
-                                                 [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan],
-                                                 [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan],
-                                                 [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
-                                                 [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, nan, nan],
-                                                 [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]],
-                                                dtype=np.float64))
-        np.testing.assert_almost_equal(np.floor(dst_src_j + 0.5),
-                                       np.array([[nan, nan, nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan],
-                                                 [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, nan, nan, nan, nan],
-                                                 [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, nan, nan, nan],
-                                                 [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, nan, nan],
-                                                 [nan, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
-                                                 [nan, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan],
-                                                 [nan, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
-                                                 [nan, nan, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]],
-                                                dtype=np.float64))
-
-        dst_rad = np.zeros((13, 13), dtype=np.float64)
-
-        extract_source_pixels(src_ds.rad.values,
-                              dst_src_i,
-                              dst_src_j,
-                              dst_rad)
+        dst_src_ij = np.full((2, 13, 13), np.nan, dtype=np.float64)
+        _compute_source_pixels(src_ds.lon.values,
+                               src_ds.lat.values,
+                               0,
+                               0,
+                               dst_src_ij,
+                               -0.25,
+                               49.75,
+                               0.5)
+
+        # print(xr.DataArray(np.floor(dst_src_i + 0.5), dims=('y', 'x')))
+        # print(xr.DataArray(np.floor(dst_src_j + 0.5), dims=('y', 'x')))
+
+        np.testing.assert_almost_equal(np.floor(dst_src_ij[0] + 0.5),
+                                       np.array([
+                                           [nan, nan, nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan],
+                                           [nan, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan],
+                                           [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan],
+                                           [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan],
+                                           [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.],
+                                           [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, nan, nan],
+                                           [nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
+                                       ],
+                                           dtype=np.float64))
+        np.testing.assert_almost_equal(np.floor(dst_src_ij[1] + 0.5),
+                                       np.array([
+                                           [nan, nan, nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan],
+                                           [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                                           [nan, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan],
+                                           [nan, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
+                                           [nan, nan, 0.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]
+                                       ],
+                                           dtype=np.float64))
+
+        dst_rad = np.full((13, 13), np.nan, dtype=np.float64)
+
+        _extract_source_pixels(src_ds.rad.values,
+                               dst_src_ij,
+                               dst_rad)
+
+        # print(xr.DataArray(dst_rad))
 
         np.testing.assert_almost_equal(dst_rad,
                                        np.array([
@@ -311,11 +316,11 @@ class RectifyDatasetTest(SourceDatasetMixin, unittest.TestCase):
                                            [nan, nan, 3.0, 4.0, 4.0, 4.0, 4.0, nan, nan, nan, nan, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0, 2.0, nan, nan, nan, nan],
                                            [3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 2.0, 2.0, 2.0, nan, nan, nan],
-                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 4.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
+                                           [nan, 3.0, 3.0, 3.0, 3.0, 3.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
                                            [nan, 3.0, 3.0, 3.0, 3.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0],
                                            [nan, 3.0, 3.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, nan, nan],
-                                           [nan, 3.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
-                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, nan, nan, nan, nan, nan],
+                                           [nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, nan, nan, nan, nan],
+                                           [nan, nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan],
                                            [nan, nan, 1.0, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]