Merge pull request #324 from pnuu/bugfix-1d-bilinear

Fix bilinear resampler for 1D data

Author: djhoese

pyresample/bilinear/_base.py

@@ -190,13 +190,17 @@ def _get_target_proj_vectors(self):
 
     def _get_slices(self):
         shp = self._source_geo_def.shape
-        cols, lines = np.meshgrid(np.arange(shp[1]),
-                                  np.arange(shp[0]))
+        try:
+            cols, lines = np.meshgrid(np.arange(shp[1]),
+                                      np.arange(shp[0]))
+            data = (np.ravel(lines), np.ravel(cols))
+        except IndexError:
+            data = (np.zeros(shp[0], dtype=np.uint32), np.arange(shp[0]))
 
         valid_lines_and_columns = array_slice_for_multiple_arrays(
             self._valid_input_index,
-            (np.ravel(lines), np.ravel(cols))
-        )
+            data)
+
         self.slices_y, self.slices_x = array_slice_for_multiple_arrays(
             self._index_array,
             valid_lines_and_columns

pyresample/bilinear/xarr.py

@@ -131,8 +131,9 @@ def _finalize_output_data(self, data, res, fill_value):
         res = self._reshape_to_target_area(res, data.ndim)
 
         self._add_missing_coordinates(data)
+        dims = self._get_output_dims(data, res)
 
-        return DataArray(res, dims=data.dims, coords=self._out_coords)
+        return DataArray(res, dims=dims, coords=self._out_coords)
 
     def _add_missing_coordinates(self, data):
         self._add_x_and_y_coordinates()
@@ -154,10 +155,16 @@ def _adjust_bands_coordinates_to_match_data(self, data_coords):
         elif 'bands' in self._out_coords:
             del self._out_coords['bands']
 
+    def _get_output_dims(self, data, res):
+        if data.ndim == res.ndim:
+            return data.dims
+        return list(self._out_coords.keys())
+
     def _slice_data(self, data, fill_value):
         def from_delayed(delayeds, shp):
             return [da.from_delayed(d, shp, np.float32) for d in delayeds]
 
+        data = _check_data_shape(data, self._valid_input_index)
         if data.ndim == 2:
             shp = self.bilinear_s.shape
         else:
@@ -257,6 +264,20 @@ def _get_valid_input_index(source_geo_def,
     return valid_input_index, source_lons, source_lats
 
 
+def _check_data_shape(data, input_idxs):
+    """Check data shape and adjust if necessary."""
+    # Handle multiple datasets
+    if data.ndim > 2 and data.shape[0] * data.shape[1] == input_idxs.shape[0]:
+        # Move the "channel" dimension first
+        data = da.moveaxis(data, -1, 0)
+
+    # Ensure two dimensions
+    if data.ndim == 1:
+        data = DataArray(da.map_blocks(np.expand_dims, data.data, 0, new_axis=[0]))
+
+    return data
+
+
 class XArrayResamplerBilinear(XArrayBilinearResampler):
     """Wrapper for the old resampler class."""
 

pyresample/test/test_bilinear.py

@@ -71,9 +71,13 @@ def setUpClass(cls):
         cls.data1 = np.ones((in_shape[0], in_shape[1]))
         cls.data2 = 2. * cls.data1
         cls.data3 = cls.data1 + 9.5
+        cls.data3_1d = np.ravel(cls.data3)
+
         lons, lats = np.meshgrid(np.linspace(-25., 40., num=in_shape[0]),
                                  np.linspace(45., 75., num=in_shape[1]))
         cls.source_def = geometry.SwathDefinition(lons=lons, lats=lats)
+        cls.source_def_1d = geometry.SwathDefinition(lons=np.ravel(lons),
+                                                     lats=np.ravel(lats))
 
         cls.radius = 50e3
         cls._neighbours = 32
@@ -331,6 +335,22 @@ def test_get_sample_from_bil_info(self):
                                        input_idxs, idx_arr)
         assert not hasattr(res, 'mask')
 
+    def test_get_sample_from_bil_info_1d(self):
+        """Test resampling using resampling indices for 1D data."""
+        from pyresample.bilinear import get_bil_info, get_sample_from_bil_info
+
+        t__, s__, input_idxs, idx_arr = get_bil_info(self.source_def_1d,
+                                                     self.target_def,
+                                                     50e5, neighbours=32,
+                                                     nprocs=1)
+        # Sample from 1D data
+        res = get_sample_from_bil_info(self.data3_1d, t__, s__,
+                                       input_idxs, idx_arr)
+        self.assertAlmostEqual(np.nanmin(res), 10.5)
+        self.assertAlmostEqual(np.nanmax(res), 10.5)
+        # Four pixels are outside of the data
+        self.assertEqual(np.isnan(res).sum(), 4)
+
     def test_resample_bilinear(self):
         """Test whole bilinear resampling."""
         from pyresample.bilinear import resample_bilinear
@@ -467,9 +487,12 @@ def setUp(self):
         self.data1 = DataArray(da.ones((in_shape[0], in_shape[1])), dims=('y', 'x'))
         self.data2 = 2. * self.data1
         self.data3 = self.data1 + 9.5
+
         lons, lats = np.meshgrid(np.linspace(-25., 40., num=in_shape[0]),
                                  np.linspace(45., 75., num=in_shape[1]))
         self.source_def = geometry.SwathDefinition(lons=lons, lats=lats)
+        self.source_def_1d = geometry.SwathDefinition(lons=np.ravel(lons),
+                                                      lats=np.ravel(lats))
 
         self.radius = 50e3
         self._neighbours = 32
@@ -714,6 +737,45 @@ def test_slice_data(self):
         self.assertTrue(np.all(np.isnan(p_1)) and np.all(np.isnan(p_2)) and
                         np.all(np.isnan(p_3)) and np.all(np.isnan(p_4)))
 
+    def test_slice_data_1d(self):
+        """Test slicing 1D data."""
+        import dask.array as da
+        from xarray import DataArray
+
+        from pyresample.bilinear import XArrayBilinearResampler
+
+        resampler = XArrayBilinearResampler(self.source_def_1d, self.target_def,
+                                            self.radius)
+        resampler.get_bil_info()
+
+        # 1D data
+        data = DataArray(da.ones(self.source_def_1d.shape))
+        p_1, p_2, p_3, p_4 = resampler._slice_data(data, np.nan)
+        self.assertEqual(p_1.shape, resampler.bilinear_s.shape)
+        self.assertTrue(p_1.shape == p_2.shape == p_3.shape == p_4.shape)
+        self.assertTrue(np.all(p_1 == 1.0) and np.all(p_2 == 1.0) and
+                        np.all(p_3 == 1.0) and np.all(p_4 == 1.0))
+
+    def test_get_sample_from_bil_info_1d(self):
+        """Test resampling using resampling indices for 1D data."""
+        import dask.array as da
+        from xarray import DataArray
+
+        from pyresample.bilinear import XArrayBilinearResampler
+
+        resampler = XArrayBilinearResampler(self.source_def_1d, self.target_def,
+                                            50e5)
+        resampler.get_bil_info()
+
+        # Sample from 1D data
+        data = DataArray(da.ones(self.source_def_1d.shape), dims=('y'))
+        res = resampler.get_sample_from_bil_info(data)  # noqa
+        assert 'x' in res.dims
+        assert 'y' in res.dims
+
+        # Four pixels are outside of the data
+        self.assertEqual(np.isnan(res).sum().compute(), 4)
+
     @mock.patch('pyresample.bilinear.xarr.np.meshgrid')
     def test_get_slices(self, meshgrid):
         """Test slice array creation."""