lime-stable 2.0.dev4__tar.gz → 2.0.dev7__tar.gz

{lime_stable-2.0.dev4/src/lime_stable.egg-info → lime_stable-2.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev4
+Version: 2.0.dev7
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later
@@ -19,7 +19,7 @@ Requires-Dist: aspect-stable~=0.3.1
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: bokeh~=3.6; extra == "full"
+Requires-Dist: bokeh~=3.7; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"
 Requires-Dist: PyLaTeX~=1.4; extra == "full"

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.dev4"
+version = "2.0.dev7"
 readme = "README.rst"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"
@@ -25,7 +25,7 @@ classifiers = ["Programming Language :: Python :: 3",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "bokeh~=3.6",
+        "bokeh~=3.7",
         "mplcursors~=0.6",
         "openpyxl~=3.1",
         "PyLaTeX~=1.4",

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/__init__.py

@@ -42,7 +42,7 @@ _logger.debug(f'Launching LiMe {__version__} in Python {__python_version__}')
 from lime.observations import Spectrum, Sample, Cube
 from lime.io import *
 from lime.tools import *
-from lime.transitions import Line, label_decomposition, bands_from_frame
+from lime.transitions import Line, label_decomposition, bands_from_measurements
 from lime.archives.read_fits import OpenFits, show_instrument_cfg
 from lime.plotting.plots import theme
 from lime.workflow import line_bands

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/archives/read_fits.py

@@ -154,7 +154,7 @@ def check_fits_source(fits_source, lime_object=None, load_function=None):
     else:
 
         if load_function is None:
-            raise LiMe_Error(f'Please introduce fits file instrument or a load function to import the fits file as a '
+            _logger.warning(f'Please introduce fits file instrument or a load function to import the fits file as a '
                              f'LiMe observation')
 
     return fits_source, spectrum_type

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/changelog.txt

@@ -109,4 +109,5 @@ LiMe Mayor update - 2.0.0 - XX/XX/XXXX
     - Rename term "_conf" to "_cfg" across function names and arguments for uniformity
     - Fitting functions now have the update_default=True argument. In the default behaviour the default configuration updates the default one. If set to update_default=False only the obj_cfg is used if available else the default one.
     - Creating a spectrum object where all the entries are masked now produces a critical warning instead of raising an error.
-    - By default line_bands
+    - By default line_bands.
+    - Added bands_from_log function

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/fitting/lines.py

@@ -180,7 +180,6 @@ def pp_FWHM(line, idx):
 
 
 def gaussian_area(line, idx, n_steps):
-
     amp = np.random.normal(line.amp[idx], line.amp_err[idx], n_steps)
     sigma = np.random.normal(line.sigma[idx], line.sigma_err[idx], n_steps)
 
@@ -470,8 +469,6 @@ class ProfileModelCompiler:
         self.model.prefix = f'line0_'
 
         # Fix or not the continuum
-        # m_cont_conf = _SLOPE_FIX_PAR if line._cont_from_adjacent else _SLOPE_FREE_PAR
-        # n_cont_conf = _INTER_FIX_PAR if line._cont_from_adjacent else _INTER_FREE_PAR
         self.define_param(0, line, 'm_cont', line.m_cont, _SLOPE_FIX_PAR, user_conf)
         self.define_param(0, line, 'n_cont', line.n_cont, _INTER_FIX_PAR, user_conf)
 
@@ -616,8 +613,11 @@ class ProfileModelCompiler:
             # Check for negative -0.0 # TODO this needs a better place # FIXME -0.0 error
             if np.signbit(line.sigma_err[i]):
                 line.sigma_err[i] = np.nan
-                if self.output.errorbars:
-                    _logger.warning(f'Negative value for profile sigma at {line.label}')
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
+
+            if np.signbit(line.amp_err[i]):
+                line.amp_err[i] = np.nan
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
 
             # Compute the profile areas
             profile_flux_dist = AREA_FUNCTIONS[line._p_shape[i]](line, i, 1000)

lime_stable-2.0.dev7/src/lime/inference/intensity_threshold.py

@@ -0,0 +1,137 @@
+import logging
+
+import numpy as np
+import pandas as pd
+
+from scipy import signal
+from lime.io import check_file_dataframe
+from lime.transitions import label_decomposition
+from lime.plotting.plots import plot_peaks_troughs
+
+try:
+    import joblib
+    joblib_check = True
+except ImportError:
+    joblib_check = False
+
+
+_logger = logging.getLogger('LiMe')
+
+MACHINE_PATH = None
+FLUX_PIXEL_CONV = np.linspace(0,1,33)
+
+
+def compute_line_width(idx_peak, spec_flux, delta_i, min_delta=2, emission_check=True):
+
+    """
+    Algororithm to measure emision line width given its peak location
+    :param idx_peak:
+    :param spec_flux:
+    :param delta_i:
+    :param min_delta:
+    :return:
+    """
+
+    i = idx_peak
+
+    if emission_check:
+        while (spec_flux[i] > spec_flux[i + delta_i]) or (np.abs(idx_peak - (i + delta_i)) <= min_delta):
+            i += delta_i
+    else:
+        while (spec_flux[i] < spec_flux[i + delta_i]) or (np.abs(idx_peak - (i + delta_i)) <= min_delta):
+            i += delta_i
+
+    return i
+
+
+
+
+class LineFinder:
+
+    def __init__(self):
+
+        return
+
+    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5,
+                       continuum_array=None, continuum_std=None, plot_steps=False, **kwargs):
+
+        """
+
+        This function compares the input lines bands in the observation spectrum to confirm the presence of lines.
+
+        The input bands can be specified as a pandas dataframe or the path to its file via the ``bands_df`` argument.
+
+        The continuum needs to be fit a priori with the Spectrum.fit.continuum function or assigning a ``continuum_array``
+        and a ``continuum_std``.
+
+        The ``sigma_threshold`` establishes the standard deviation factor beyond which a positive line detection is assumed.
+
+        By default the algorithm seeks for emission lines, set ``emission_type`` equal to False for absorption lines.
+
+        The additional arguments provide additional utils to adjust the line detection and show the steps/results.
+
+        :param bands: Input bands dataframe or the address to its file.
+        :type bands: pandas.Dataframe, str, pathlib.Path
+
+        :param sigma_threshold: Continuum standard deviation factor for line detection. The default value is 3.
+        :type sigma_threshold: float, optional
+
+        :param emission_type: Line type. The default value is "True" for emission lines.
+        :type emission_type: str, optional
+
+        :param width_tol: Minimum number of pixels between peaks/troughs. The default value is 5.
+        :type width_tol: float, optional
+
+        :param ml_detection: Machine learning algorithm to detect lines. The default value is None.
+        :type ml_detection: str, optional
+
+        :param plot_steps: Plot the detected peaks/troughs. The default value is False
+        :type plot_steps: bool, optional
+
+        """
+
+        # TODO Lime2.0 replace by warning with new retrieve line bands
+        # Check for the peaks of the emission lines
+        continuum_array = self._spec.cont if continuum_array is None else continuum_array
+        continuum_std = self._spec.cont_std if continuum_std is None else continuum_std
+
+        # Get indeces of peaks
+        limit_threshold = sigma_threshold * continuum_std
+        limit_threshold = continuum_array + limit_threshold if emission_type else continuum_array + limit_threshold
+        idcs_peaks, _ = signal.find_peaks(self._spec.flux, height=limit_threshold, distance=width_tol)
+
+        # Match peaks with theoretical lines
+        bands = check_file_dataframe(bands)
+        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, line_type=emission_type)
+
+        # Plot the results
+        if plot_steps:
+            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, **kwargs)
+
+        return matched_DF
+
+
+    def label_peaks(self, idcs_peaks, matched_DF, line_type='emission', width_tol=5):
+
+        # Security check in case no lines detected
+        if len(idcs_peaks) == 0:
+            return pd.DataFrame(columns=matched_DF.columns)
+
+        # Add theoretical wavelength values if necessary
+        if 'wavelength' not in matched_DF.columns:
+            matched_DF['wavelength'] = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
+
+        # Get bands limits indexes
+        idcs_w3 = np.searchsorted(self._spec.wave_rest, matched_DF.w3)
+        idcs_w4 = np.searchsorted(self._spec.wave_rest, matched_DF.w4)
+
+        # Get the bands matching
+        band_contains_peak = (idcs_peaks[None, :] > idcs_w3[:, None]) & (idcs_peaks[None, :] < idcs_w4[:, None])
+        idcs_matched_bands = band_contains_peak.any(axis=1)
+        idcs_matched_peaks = idcs_peaks[band_contains_peak.argmax(axis=1)[idcs_matched_bands]]
+
+        # Crop the bands to the detection
+        matched_DF.loc[idcs_matched_bands, 'observation'] = 'detected'
+        matched_DF.loc[idcs_matched_bands, 'signal_peak'] = idcs_matched_peaks
+
+        return matched_DF.loc[idcs_matched_bands]

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/lime.toml

@@ -1,3 +1,3 @@
 [metadata]
 name = 'lime-stable'
-version = "2.0.dev4"
+version = "2.0.dev7"

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/plotting/bokeh_plots.py

@@ -102,14 +102,7 @@ def bokeh_bands(fig, bands, x, y, z_corr, redshift):
 
     # Loop through the detections and plot the names
     for i in np.arange(latex.size):
-        if idcs_band_limits[0, i] != idcs_band_limits[0, i]:  # Y limit for the label check if same pixel
-            max_region = np.max(y[idcs_band_limits[0, i]:idcs_band_limits[0, i]])
-        else:
-            max_region = y[idcs_band_limits[0, i]]
-
-        label = 'Matched line' if i == 0 else '_'
         fig.add_layout(BoxAnnotation(left=w3_obs[i]/z_corr, right=w4_obs[i]/z_corr, fill_alpha=0.3, fill_color=theme.colors['match_line']))
-        # axis.text(wave_array[i] * (1 + redshift) / z_corr, max_region * 0.9 * z_corr, latex[i], rotation=270)
 
     return
 
@@ -124,16 +117,25 @@ def bands_filling_bokeh(fig, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
         low_lim = 0 if np.isnan(low_lim) else low_lim
 
         # Central bands
+        print('1',x[idcs_mask[2]:idcs_mask[3]]/z_corr)
+        print('1',y[idcs_mask[2]:idcs_mask[3]]*z_corr)
+        print('1',low_lim*z_corr)
         fig.varea_step(x=x[idcs_mask[2]:idcs_mask[3]]/z_corr, y1=low_lim*z_corr, y2=y[idcs_mask[2]:idcs_mask[3]]*z_corr,
                         step_mode="center", fill_alpha=0.25, color=color_dict['line_band'])
 
         # Continua bands exclusion
         if exclude_continua is False:
+            print('2', x[idcs_mask[0]:idcs_mask[1]]/z_corr)
+            print('2', low_lim*z_corr)
+            print('2', y[idcs_mask[0]:idcs_mask[1]]*z_corr)
             fig.varea_step(x=x[idcs_mask[0]:idcs_mask[1]]/z_corr,
                            y1=low_lim*z_corr,
                            y2=y[idcs_mask[0]:idcs_mask[1]]*z_corr,
                            step_mode="center", fill_alpha=0.25, color=color_dict['cont_band'])
 
+            print('3', x[idcs_mask[4]:idcs_mask[5]]/z_corr)
+            print('3', low_lim*z_corr)
+            print('3', y[idcs_mask[4]:idcs_mask[5]]*z_corr)
             fig.varea_step(x=x[idcs_mask[4]:idcs_mask[5]]/z_corr,
                            y1=low_lim*z_corr,
                            y2=y[idcs_mask[4]:idcs_mask[5]]*z_corr,
@@ -193,8 +195,8 @@ class BokehFigures:
 
         return
 
-    def bands(self, label, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, log_scale=True, fig_cfg=None,
-              ax_cfg=None, return_fig=False):
+    def bands(self, label, output_address=None, bands=None, include_fits=True, rest_frame=False, log_scale=True,
+              exclude_continua=True, fig_cfg=None, ax_cfg=None, return_fig=False):
 
 
         # Unpack variables
@@ -205,7 +207,7 @@ class BokehFigures:
         legend_check = True if label is not None else False
 
         # Check which line should be plotted
-        line = parse_bands_arguments(label, log, ref_bands, norm_flux)
+        line = parse_bands_arguments(label, log, bands, norm_flux)
 
         # Proceed to plot
         if line is not None:
@@ -232,16 +234,13 @@ class BokehFigures:
             # Create figure with default utils if not provided
             fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"), y_axis_type=scale_str)
 
-            # # Create figure with default utils if not provided
-            # fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"))
-
             # Spectrum data source
             source = ColumnDataSource(data={"x": wave_plot[idcs_bands[0]:idcs_bands[5]] / z_corr,
                                             "y": flux_plot[idcs_bands[0]:idcs_bands[5]] * z_corr})
             fig.step("x", "y", source=source, color=theme.colors['fg'], line_width=1, mode='center')
 
             # Fille the bands
-            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line)
+            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line, exclude_continua=exclude_continua)
 
             # Plot labels
             fig.xaxis.axis_label = AXES_CONF['xlabel']
@@ -250,6 +249,9 @@ class BokehFigures:
             # Adjust the format of the plot
             update_bokeh_figure(fig, PLT_CONF)
 
+            # Hide the legend if there are line profiles
+            fig.legend.visible = legend_check
+
             # Save or display the plot
             if return_fig:
                 return fig
@@ -258,11 +260,14 @@ class BokehFigures:
                 save(fig, filename=output_address)
 
             else:
-                # output_notebook()
                 show(fig)
 
+        else:
+            _logger.info(f'The input line {label} could not be found')
+
         return
 
+
     def grid(self, output_address=None, rest_frame=True, log_scale=False, n_cols=6, n_rows=None, col_row_scale=(2, 1.5),
              include_fits=True, in_fig=None, fig_cfg=None, ax_cfg=None, maximize=False):
 
@@ -410,6 +415,9 @@ class BokehFigures:
         # Adjust the format of the plot
         update_bokeh_figure(fig, PLT_CONF)
 
+        # Hide the legend if there are line profiles
+        fig.legend.visible = legend_check
+
         # Save or display the plot
         if return_fig:
             return fig

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/plotting/format.py

@@ -54,6 +54,7 @@ class Themer:
         self.conf = None        # All the formating data
         self.style = None       # Label of the active style
         self.active_conf = None   # Dictionary with the active figure configuration and library
+        self.default_lib = 'matplotlib'
 
         # LiMe plots personalization
         self.colors = None      # Features individual colors
@@ -67,6 +68,8 @@ class Themer:
         self.conf = conf.copy()
         self.set_style(style)
 
+
+
         return
 
 
@@ -163,7 +166,7 @@ class Themer:
         return ax_cfg
 
 
-    def set_style(self, style=None, scale=None, colors_conf=None, library=None):
+    def set_style(self, style=None, scale=None, colors_conf=None, library='matplotlib'):
 
         # Set the default style
         # self.style = ['default']
@@ -173,6 +176,7 @@ class Themer:
         #     self.style += [style] if isinstance(style, str) else style
         self.style = 'default' if style is None else style
         self.scale = ['default'] if style is None else [scale]
+        self.default_lib = library
 
         # Set the library defaults
         self.active_conf = {'matplotlib': self.conf['matplotlib']['default'].copy(),

{lime_stable-2.0.dev4 → lime_stable-2.0.dev7}/src/lime/plotting/plots.py

@@ -159,7 +159,10 @@ def _auto_flux_scale(axis, y, y_scale, scale_dict=theme.plt):
             ratio = np.abs(y_max/y_min)
             if (ratio > 25) or (ratio < 0.06):
                 if neg_check:
-                    y_scale = {'value': 'symlog', 'linthresh': min(np.ceil(np.abs(y_min)), np.min(y[y>0]))}
+                    if np.sum(y>0) > 1:
+                        y_scale = {'value': 'symlog', 'linthresh': min(np.ceil(np.abs(y_min)), np.min(y[y>0]))}
+                    else:
+                        y_scale = {'value': 'symlog', 'linthresh': np.ceil(np.abs(y_min))}
                 else:
                     y_scale = {'value': 'log'}
             else:
@@ -657,7 +660,7 @@ def redshift_permu_evaluation(spectrum, z_infered, obs_wave_arr, theo_wave_arr,
 def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=False, color_dict=theme.colors, show_central=True):
 
     # Security check for low selection
-    if len(x[idcs_mask[2]:idcs_mask[3]]) > 1:
+    if y[idcs_mask[2]:idcs_mask[3]].size > 1:
 
         # Lower limit for the filled region
         if exclude_continua is False:
@@ -666,10 +669,10 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
             x_interval = x[idcs_mask[2]:idcs_mask[3]]
             y_interval = y[idcs_mask[2]:idcs_mask[3]]
         else:
-            m = (y[idcs_mask[3]] - y[idcs_mask[2]])/(x[idcs_mask[3]] - x[idcs_mask[2]])
-            n = y[idcs_mask[2]] - m * x[idcs_mask[2]]
             x_interval = x[idcs_mask[2]:idcs_mask[3]]
             y_interval = y[idcs_mask[2]:idcs_mask[3]]
+            m = (y_interval[-1] - y_interval[0])/(x_interval[-1] - x_interval[0])
+            n = y_interval[0] - m * x_interval[0]
             low_lim = m * x_interval + n
 
         # Central bands
@@ -690,7 +693,7 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
     return
 
 
-def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, log_scale=False):
+def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, **kwargs):
 
     norm_flux = spec.norm_flux
     wave = spec.wave
@@ -724,9 +727,6 @@ def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, lo
         ax.scatter(wave_plot[idcs_mask], flux_plot[idcs_mask], label='Masked pixels', marker='x',
                    color=theme.colors['mask_marker'])
 
-        if log_scale:
-            ax.set_yscale('log')
-
         ax.legend()
         ax.update(AXES_CONF)
         plt.tight_layout()
@@ -783,7 +783,6 @@ class Plotter:
 
         # Loop through the detections and plot the names
         for i, line_label in enumerate(match_log.index):
-            print(line_label)
             line = Line(line_label, match_log)
 
             # Get the max flux on the region making the exception for 1 pixel bands
@@ -792,7 +791,7 @@ class Plotter:
 
             x_text = line.wavelength * (1 + redshift)/z_corr if not line.blended_check else line.wavelength[0] * (1 + redshift)/z_corr
             y_text = max_region * 0.9 * z_corr
-            text = line.latex_label[0]
+            text = line.label
 
             axis.text(x_text, y_text, text, rotation=270)
             axis.axvspan(x[idx_w3]/z_corr, x[idx_w4]/z_corr, label='Matched line' if i == 0 else '_', alpha=0.30,
@@ -1009,84 +1008,79 @@ class SpectrumFigures(Plotter):
                 in_ax.fill_between(wave_plot/z_corr, low_limit*z_corr, high_limit*z_corr, alpha=0.2,
                                    color=theme.colors['fade_fg'])
 
-            # Include the detection bands
-            if detection_band is not None:
-
-                detec_obj = getattr(self._spec.infer, detection_band)
-
-                if detec_obj.confidence is not None:
-
-                    # Boundaries array for confidence intervals
-                    bounds = np.array([0.0, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-
-                    # Adjust color map to match lower detection limit to fg color
-                    cmap = plt.get_cmap(theme.colors['mask_map'])
-                    cmaplist = [cmap(i) for i in range(cmap.N)]
-                    cmaplist[0] = theme.colors['fg']
-                    cmap = colors.LinearSegmentedColormap.from_list('mcm', cmaplist, bounds.size-1)
-                    norm = colors.BoundaryNorm(bounds * 100, cmap.N)
-
-                    # Iterate through the confidence intervals and plot the step spectrum
-                    for i in range(1, len(bounds)):
-                        if i > 1:
-                            idcs = detec_obj(bounds[i-1]*100, confidence_max=bounds[i]*100)
-                            wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
-                            wave_nan[idcs], flux_nan[idcs] = wave_plot[idcs] / z_corr, flux_plot[idcs] * z_corr
-
-                            in_ax.step(wave_nan, flux_nan, label=label, where='mid', color=cmap(i-1))
-
-                    # Color bar
-                    sm = cm.ScalarMappable(cmap=cmap, norm=norm)
-                    sm.set_array([])
-                    cbar = plt.colorbar(sm, ax=in_ax)
-                    cbar.set_label('Detection confidence %', rotation=270, labelpad=35)
-
-
-                else:
-                    _logger.warning(f'The line detection bands confidence has not been calculated. They are not included'
-                                    f' on plot.')
-
-            if show_categories:
-                # Define the bins you want
-                bins = [40, 60, 80, 100]
+            # # Include the detection bands
+            # if detection_band is not None:
+            #
+            #     detec_obj = getattr(self._spec.infer, detection_band)
+            #
+            #     if detec_obj.confidence is not None:
+            #
+            #         # Boundaries array for confidence intervals
+            #         bounds = np.array([0.0, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+            #
+            #         # Adjust color map to match lower detection limit to fg color
+            #         cmap = plt.get_cmap(theme.colors['mask_map'])
+            #         cmaplist = [cmap(i) for i in range(cmap.N)]
+            #         cmaplist[0] = theme.colors['fg']
+            #         cmap = colors.LinearSegmentedColormap.from_list('mcm', cmaplist, bounds.size-1)
+            #         norm = colors.BoundaryNorm(bounds * 100, cmap.N)
+            #
+            #         # Iterate through the confidence intervals and plot the step spectrum
+            #         for i in range(1, len(bounds)):
+            #             if i > 1:
+            #                 idcs = detec_obj(bounds[i-1]*100, confidence_max=bounds[i]*100)
+            #                 wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
+            #                 wave_nan[idcs], flux_nan[idcs] = wave_plot[idcs] / z_corr, flux_plot[idcs] * z_corr
+            #
+            #                 in_ax.step(wave_nan, flux_nan, label=label, where='mid', color=cmap(i-1))
+            #
+            #         # Color bar
+            #         sm = cm.ScalarMappable(cmap=cmap, norm=norm)
+            #         sm.set_array([])
+            #         cbar = plt.colorbar(sm, ax=in_ax)
+            #         cbar.set_label('Detection confidence %', rotation=270, labelpad=35)
+            #
+            #
+            #     else:
+            #         _logger.warning(f'The line detection bands confidence has not been calculated. They are not included'
+            #                         f' on plot.')
+
+            # Show components
+            if show_categories and self._spec.infer.pred_arr is not None:
 
                 # Use np.histogram to get the counts in each bin
-                if self._spec.infer.pred_arr is not None:
-                    if aspect_check:
-                        categories = np.sort(np.unique(self._spec.infer.pred_arr))
-                        legend_scatter = []
-
-                        for category in categories:
-                            if category != 0:
-
-                                # Get category properties
-                                feature_name = self._spec.infer.model_mgr.medium.number_feature_dict[category]
-                                feature_color = aspect.cfg['colors'][feature_name]
-                                idcs_feature = self._spec.infer.pred_arr == category
-                                legend_scatter.append(mlines.Line2D([], [], marker='o', color='w',
-                                                                    markerfacecolor=feature_color, markersize=8, label=feature_name))
-
-                                # Count the pixels for each category
-                                counts, _ = np.histogram(self._spec.infer.conf_arr[idcs_feature], bins=bins)
-                                for idx_conf, count_conf in enumerate(counts):
-                                    if count_conf > 0:
-
-                                        # Get indeces matching the detections
-                                        idcs_count = np.where((bins[idx_conf] < self._spec.infer.conf_arr[idcs_feature]) &
-                                                              (self._spec.infer.conf_arr[idcs_feature] <= bins[idx_conf + 1]))[0]
-                                        idcs_nonnan = np.where(idcs_feature)[0][idcs_count]  # Returns indices where mask is True
-
-                                        # Generate nan arrays with the data to avoid filling non detections
-                                        wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
-                                        wave_nan[idcs_nonnan] = wave_plot[idcs_nonnan] / z_corr
-                                        flux_nan[idcs_nonnan] = flux_plot[idcs_nonnan] * z_corr
-
-                                        # Plot with the corresponding colors and linestyle
-                                        in_ax.step(wave_nan, flux_nan, label=feature_name, where='mid', color=feature_color,
-                                                   linestyle=category_conf_styles[idx_conf])
-
-                    else:
-                        _logger.warning('Aspect needs to be installed to display the spectrum components')
+                categories = np.sort(np.unique(self._spec.infer.pred_arr))
+                legend_scatter = []
+
+                for category in categories:
+                    if category != 0:
+
+                        # Get category properties
+                        feature_name = self._spec.infer.model_mgr.medium.number_feature_dict[category]
+                        feature_color = aspect.cfg['colors'][feature_name]
+                        idcs_feature = self._spec.infer.pred_arr == category
+                        legend_scatter.append(mlines.Line2D([], [], marker='o', color='w',
+                                                            markerfacecolor=feature_color, markersize=8, label=feature_name))
+
+                        # Count the pixels for each category
+                        bins = [40, 60, 80, 100]
+                        counts, _ = np.histogram(self._spec.infer.conf_arr[idcs_feature], bins=bins)
+                        for idx_conf, count_conf in enumerate(counts):
+                            if count_conf > 0:
+
+                                # Get indeces matching the detections
+                                idcs_count = np.where((bins[idx_conf] < self._spec.infer.conf_arr[idcs_feature]) &
+                                                      (self._spec.infer.conf_arr[idcs_feature] <= bins[idx_conf + 1]))[0]
+                                idcs_nonnan = np.where(idcs_feature)[0][idcs_count]  # Returns indices where mask is True
+
+                                # Generate nan arrays with the data to avoid filling non detections
+                                wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
+                                wave_nan[idcs_nonnan] = wave_plot[idcs_nonnan] / z_corr
+                                flux_nan[idcs_nonnan] = flux_plot[idcs_nonnan] * z_corr
+
+                                # Plot with the corresponding colors and linestyle
+                                in_ax.step(wave_nan, flux_nan, label=feature_name, where='mid', color=feature_color,
+                                           linestyle=category_conf_styles[idx_conf])
 
                     # Legend category
                     legend_category = in_ax.legend(handles=legend_scatter, edgecolor=theme.colors['fg'])
@@ -1275,8 +1269,8 @@ class SpectrumFigures(Plotter):
 
         return in_fig
 
-    def bands(self, label=None, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, y_scale='auto', fig_cfg=None,
-              ax_cfg=None, in_fig=None, maximize=False, show_err=True):
+    def bands(self, label=None, bands=None, output_address=None, include_fits=True, rest_frame=False, y_scale='auto', fig_cfg=None,
+              ax_cfg=None, in_fig=None, maximize=False, show_err=False, exclude_continua=False):
 
         """
 
@@ -1333,7 +1327,7 @@ class SpectrumFigures(Plotter):
         display_check = True if in_fig is None else False
 
         # Check which line should be plotted
-        line = parse_bands_arguments(label, log, ref_bands, norm_flux)
+        line = parse_bands_arguments(label, bands, log, norm_flux)
 
         # Check the observation has uncertainty to display
         if show_err and (self._spec.err_flux is None):
@@ -1378,13 +1372,13 @@ class SpectrumFigures(Plotter):
                 idcs_bands = line.index_bands(self._spec.wave, self._spec.redshift, just_band_edges=True)
 
                 # Plot the spectrum
-                label_leg = line.latex_label if (line.latex_label is not None and include_fits is False) else None
+                label_leg = line.latex_label[0] if (line.latex_label[0] is not None and include_fits is False) else None
                 in_ax[0].step(wave_plot[idcs_bands[0]:idcs_bands[5]] / z_corr, flux_plot[idcs_bands[0]:idcs_bands[5]] * z_corr,
                               where='mid', color=theme.colors['fg'], label=label_leg, linewidth=theme.plt['spectrum_width'])
 
                 # Continuum bands
                 bands_filling_plot(in_ax[0], wave_plot, flux_plot, z_corr, idcs_bands, line, color_dict=theme.colors,
-                                   show_central=not show_err)
+                                   show_central=not show_err, exclude_continua=exclude_continua)
 
                 if show_err:
                     err_plot = self._spec.err_flux.data