Bugfix: Fix handling ragged-->2d-->1d transitions

pyxem/signals/diffraction_vectors.py

@@ -218,7 +218,9 @@ def from_peaks(
             )
 
         if column_names is None and peaks.metadata.has_item("Peaks.signal_axes"):
-            column_names = [ax.name for ax in peaks.metadata.Peaks.signal_axes[::-1]]
+            column_names = [
+                str(ax.name) for ax in peaks.metadata.Peaks.signal_axes[::-1]
+            ]
         elif column_names is not None:
             pass
         else:
@@ -650,17 +652,38 @@ def flatten_diffraction_vectors(
             nav_positions = self._get_navigation_positions(
                 flatten=False, real_units=real_units
             )
-            vectors = np.vstack(
-                [
-                    np.hstack(
-                        [
-                            np.tile(nav_positions[ind][::-1], (len(self.data[ind]), 1)),
-                            self.data[ind],
-                        ]
-                    )
-                    for ind in np.ndindex(self.axes_manager._navigation_shape_in_array)
-                ]
-            )
+            if self.num_columns == 1:
+                vectors = np.vstack(
+                    [
+                        np.hstack(
+                            [
+                                np.tile(
+                                    nav_positions[ind][::-1], (len(self.data[ind]), 1)
+                                ),
+                                self.data[ind][:, np.newaxis],
+                            ]
+                        )
+                        for ind in np.ndindex(
+                            self.axes_manager._navigation_shape_in_array
+                        )
+                    ]
+                )
+            else:
+                vectors = np.vstack(
+                    [
+                        np.hstack(
+                            [
+                                np.tile(
+                                    nav_positions[ind][::-1], (len(self.data[ind]), 1)
+                                ),
+                                self.data[ind],
+                            ]
+                        )
+                        for ind in np.ndindex(
+                            self.axes_manager._navigation_shape_in_array
+                        )
+                    ]
+                )
         else:
             nav_positions = self._get_navigation_positions(
                 flatten=True, real_units=real_units

pyxem/tests/signals/test_diffraction_vectors.py

@@ -409,6 +409,10 @@ def test_flatten_vectors(self, diffraction_vectors_map, real_units):
         assert vectors.data.shape == (32, 4)
         assert vectors.ragged == False
 
+    def test_flatten_vectors1d(self, diffraction_vectors_map):
+        oned_vectors = diffraction_vectors_map.ivec[0]
+        vectors = oned_vectors.flatten_diffraction_vectors()
+
     def test_get_navigation_positions(self):
         test_data = np.empty((2, 3), dtype=object)
         for i in np.ndindex(test_data.shape):
@@ -760,6 +764,10 @@ def test_slicing(self, vectors):
         sliced = vectors.ivec[:, vectors.ivec[0] > 101]
         assert sliced.data[0, 0].shape == (0, 2)
 
+    def test_slicing_first(self, vectors):
+        with pytest.raises(ValueError):
+            sliced = vectors.ivec[:, 0]
+
     def test_slicing_lazy(self, vectors):
         vectors = vectors.as_lazy()
         sliced = vectors.ivec[:, vectors.ivec[0] > 101]

pyxem/utils/_slicers.py

@@ -17,6 +17,7 @@
 # along with pyXem.  If not, see <http://www.gnu.org/licenses/>.
 
 import numpy as np
+from hyperspy.signal import BaseSignal
 
 
 def slice_signal(arr, col_slice, row_slice):
@@ -39,7 +40,7 @@ def __getitem__(self, item):
         if isinstance(item, tuple):  # multiple dimensions
             if len(item) == 0 or len(item) > 2:
                 raise ValueError(
-                    "Only column and row slicing 2-D arrays is currenlty supported"
+                    "Only column and row slicing 2-D arrays is currently supported"
                 )
             col_slice = self.str2slice(item[0])
             if len(item) == 2:
@@ -51,6 +52,11 @@ def __getitem__(self, item):
             row_slice = slice(None)
         if self.signal.ragged:
             kwargs = dict(output_signal_size=(), output_dtype=object)
+            if not isinstance(row_slice, slice):
+                if not isinstance(row_slice, BaseSignal) or not row_slice.ragged:
+                    raise ValueError(
+                        "Only ragged boolean indexing is currently supported for ragged signals"
+                    )
         else:
             kwargs = dict()