Fix case in to_unit where limits are converted from Fnu to Flam

jdaviz/app.py

@@ -112,6 +112,15 @@ def to_unit(self, data, cid, values, original_units, target_units):
                 eqv = []
             else:
                 eqv = []
+
+                # If there are only two values, this is likely the limits being converted, so then
+                # in case we need to use the spectral density equivalency, we need to provide only
+                # to spectral axis values. If there is only one value
+                if not np.isscalar(values) and len(values) == 2:
+                    spectral_values = spec.spectral_axis[0]
+                else:
+                    spectral_values = spec.spectral_axis
+
                 # Ensure a spectrum passed through Spectral Extraction plugin
                 if '_pixel_scale_factor' in spec.meta and len(values) != 2:
 
@@ -120,21 +129,21 @@ def to_unit(self, data, cid, values, original_units, target_units):
                     # target_units dictate the conversion to take place.
 
                     if (u.sr in u.Unit(original_units).bases) and \
-                        (u.sr not in u.Unit(target_units).bases):
+                           (u.sr not in u.Unit(target_units).bases):
                         # Surface Brightness -> Flux
                         eqv = [(u.MJy / u.sr,
                                 u.MJy,
                                 lambda x: (x * np.array(spec.meta['_pixel_scale_factor'])),
                                 lambda x: x)]
                     elif (u.sr not in u.Unit(original_units).bases) and \
-                        (u.sr in u.Unit(target_units).bases):
+                            (u.sr in u.Unit(target_units).bases):
                         # Flux -> Surface Brightness
                         eqv = [(u.MJy,
                                 u.MJy / u.sr,
                                 lambda x: (x / np.array(spec.meta['_pixel_scale_factor'])),
                                 lambda x: x)]
                     else:
-                        eqv = u.spectral_density(spec.spectral_axis)
+                        eqv = u.spectral_density(spectral_values)
 
                 elif len(values) == 2:
                     # Need this for setting the y-limits
@@ -162,7 +171,7 @@ def to_unit(self, data, cid, values, original_units, target_units):
                                      lambda x: x)]
 
                 else:
-                    eqv = u.spectral_density(spec.spectral_axis)
+                    eqv = u.spectral_density(spectral_values)
 
         else:  # spectral axis
             eqv = u.spectral() + u.pixel_scale(1*u.pix)

jdaviz/tests/test_app.py

@@ -230,6 +230,34 @@ def test_to_unit(cubeviz_helper):
 
     value = uc.to_unit(cubeviz_helper, data, cid, value, original_units, target_units)
 
-    # will be a uniform array since not wavelength dependent
     # so test first value in array
     assert np.allclose(value[0], 4.800000041882413e-08)
+
+    # Change from Fnu to Flam (with values shape matching spectral axis)
+
+    values = np.ones(3001)
+    original_units = u.MJy
+    target_units = u.erg / u.cm**2 / u.s / u.AA
+
+    new_values = uc.to_unit(cubeviz_helper, data, cid, values, original_units, target_units)
+
+    assert np.allclose(new_values,
+                       (values * original_units)
+                       .to_value(target_units,
+                                 equivalencies=u.spectral_density(cube.spectral_axis)))
+
+    # Change from Fnu to Flam (with a shape (2,) array of values indicating we
+    # are probably converting the limits)
+
+    values = [1, 2]
+    original_units = u.MJy
+    target_units = u.erg / u.cm**2 / u.s / u.AA
+
+    new_values = uc.to_unit(cubeviz_helper, data, cid, values, original_units, target_units)
+
+    # In this case we do a regular spectral density conversion, but using the
+    # first value in the spectral axis for the equivalency
+    assert np.allclose(new_values,
+                       ([1, 2] * original_units)
+                       .to_value(target_units,
+                                 equivalencies=u.spectral_density(cube.spectral_axis[0])))