add power colors

modules/QuickLook/AveragePowerSpectrum.py

@@ -4,6 +4,7 @@ from utils.globals import loaded_event_data
 import pandas as pd
 import warnings
 import hvplot.pandas
+import holoviews.operation.datashader as hd
 from utils.DashboardClasses import (
     MainHeader,
     MainArea,
@@ -17,6 +18,12 @@ from utils.DashboardClasses import (
 )
 from stingray import AveragedPowerspectrum
 
+colors = [
+    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b",
+    "#e377c2", "#7f7f7f", "#bcbd22", "#17becf", "#aec7e8", "#ffbb78",
+    "#98df8a", "#ff9896", "#c5b0d5", "#c49c94", "#f7b6d2", "#c7c7c7",
+    "#dbdb8d", "#9edae5"
+]
 
 # Create a warning handler
 def create_warning_handler():
@@ -26,8 +33,6 @@ def create_warning_handler():
 
 
 """ Header Section """
-
-
 def create_quicklook_avg_powerspectrum_header(
     header_container,
     main_area_container,
@@ -46,29 +51,21 @@ def create_quicklook_avg_powerspectrum_header(
 
 
 """ Output Box Section """
-
-
 def create_loadingdata_output_box(content):
     return OutputBox(output_content=content)
 
 
 """ Warning Box Section """
-
-
 def create_loadingdata_warning_box(content):
     return WarningBox(warning_content=content)
 
 
 """ Float Panel """
-
-
 def create_floatpanel_area(content, title):
     return FloatingPlot(content=content, title=title)
 
 
 """ Main Area Section """
-
-
 def create_avg_powerspectrum_tab(
     output_box_container,
     warning_box_container,
@@ -83,12 +80,12 @@ def create_avg_powerspectrum_tab(
         options={name: i for i, (name, event) in enumerate(loaded_event_data)},
     )
 
-    dt_slider = pn.widgets.FloatSlider(
+    dt_input = pn.widgets.FloatInput(
         name="Select dt",
-        start=0.1,
-        end=1000,
-        step=0.1,
-        value=1,
+        value=1.0,
+        step=0.0001,
+        start=0.0000000001,
+        end=1000.0,
     )
 
     norm_select = pn.widgets.Select(
@@ -108,12 +105,14 @@ def create_avg_powerspectrum_tab(
     )
 
     floatpanel_plots_checkbox = pn.widgets.Checkbox(
-        name="Add Plot to FloatingPanel", value=False
+        name="Add Plot to FloatingPanel", value=True
     )
 
     dataframe_checkbox = pn.widgets.Checkbox(
         name="Add DataFrame to FloatingPanel", value=False
     )
+    
+    rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
 
     # Internal functions to encapsulate functionality
     def create_dataframe(selected_event_list_index, dt, norm, segment_size):
@@ -168,17 +167,80 @@ def create_avg_powerspectrum_tab(
     def create_holoviews_panes(plot):
         return pn.pane.HoloViews(plot, width=600, height=600)
 
-    def create_holoviews_plots(ps, title, dt, norm, segment_size):
+    def create_holoviews_plots(ps, title, dt, norm, segment_size, color_key=None):
+        label = f"{title} (dt={dt}, norm={norm}, segment={segment_size})"
+        plot = hv.Curve((ps.freq, ps.power), label=label).opts(
+            xlabel="Frequency (Hz)",
+            ylabel="Power",
+            width=600,
+            height=600,
+            shared_axes=False,
+        )
+
+        if color_key:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot, line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=True,
+                )
+            else:
+                return plot
+        else:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot, line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    colorbar=True,
+                    cmap="Viridis",
+                )
+            else:
+                return plot
+
+    def create_holoviews_plots_no_colorbar(ps, title, dt, norm, segment_size, color_key=None):
         label = f"{title} (dt={dt}, norm={norm}, segment={segment_size})"
-        return hv.Curve((ps.freq, ps.power), label=label).opts(
+        plot = hv.Curve((ps.freq, ps.power), label=label).opts(
             xlabel="Frequency (Hz)",
             ylabel="Power",
-            title=f"{title} (dt={dt}, norm={norm}, segment={segment_size})",
             width=600,
             height=600,
             shared_axes=False,
         )
 
+        if color_key:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot, line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                )
+            else:
+                return plot
+        else:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot, line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                    cmap="Viridis",
+                )
+            else:
+                return plot
+
     def create_dataframe_panes(df, title, dt, norm, segment_size):
         return pn.FlexBox(
             pn.pane.Markdown(f"**{title} (dt={dt}, norm={norm}, segment={segment_size})**"),
@@ -203,7 +265,7 @@ def create_avg_powerspectrum_tab(
             ]
             return
 
-        dt = dt_slider.value
+        dt = dt_input.value
         norm = norm_select.value
         segment_size = segment_size_input.value
         df, ps = create_dataframe(selected_event_list_index, dt, norm, segment_size)
@@ -252,7 +314,7 @@ def create_avg_powerspectrum_tab(
             ]
             return
 
-        dt = dt_slider.value
+        dt = dt_input.value
         norm = norm_select.value
         segment_size = segment_size_input.value
         df, ps = create_dataframe(selected_event_list_index, dt, norm, segment_size)
@@ -262,7 +324,7 @@ def create_avg_powerspectrum_tab(
                 float_panel_container.append(
                     create_floatpanel_area(
                         content=dataframe_output,
-                        title=f"DataFrame for {loaded_event_data[selected_event_list_index][0]}",
+                        title=f"DataFrame for {loaded_event_list[selected_event_list_index][0]}",
                     )
                 )
             else:
@@ -287,13 +349,13 @@ def create_avg_powerspectrum_tab(
         combined_title = []
 
         for index in selected_event_list_indices:
-            dt = dt_slider.value
+            dt = dt_input.value
             norm = norm_select.value
             segment_size = segment_size_input.value
             df, ps = create_dataframe(index, dt, norm, segment_size)
             if df is not None:
                 event_list_name = loaded_event_data[index][0]
-                plot_hv = create_holoviews_plots(ps, title=event_list_name, dt=dt, norm=norm, segment_size=segment_size)
+                plot_hv = create_holoviews_plots_no_colorbar(ps, title=event_list_name, dt=dt, norm=norm, segment_size=segment_size)
                 combined_plots.append(plot_hv)
                 combined_title.append(event_list_name)
 
@@ -345,12 +407,13 @@ def create_avg_powerspectrum_tab(
 
     tab_content = pn.Column(
         event_list_dropdown,
-        dt_slider,
+        dt_input,
         norm_select,
         segment_size_input,
         multi_event_select,
         floatpanel_plots_checkbox,
         dataframe_checkbox,
+        rasterize_checkbox,
         pn.Row(generate_powerspectrum_button, show_dataframe_button, combine_plots_button),
     )
     return tab_content

modules/QuickLook/LightCurve.py

@@ -1,6 +1,7 @@
 import panel as pn
 import holoviews as hv
 import holoviews.operation.datashader as hd
+from holoviews.operation.timeseries import rolling, rolling_outlier_std 
 from utils.globals import loaded_event_data
 import pandas as pd
 import warnings
@@ -115,28 +116,108 @@ def create_lightcurve_tab(
     )
 
     floatpanel_plots_checkbox = pn.widgets.Checkbox(
-        name="Add Plot to FloatingPanel", value=False
+        name="Add Plot to FloatingPanel", value=True
     )
 
     dataframe_checkbox = pn.widgets.Checkbox(
         name="Add DataFrame to FloatingPanel", value=False
     )
+    rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
 
     def create_holoviews_panes(plot):
         return pn.pane.HoloViews(plot, width=600, height=600, linked_axes=False)
 
     def create_holoviews_plots(df, label, dt, color_key=None):
+
         plot = df.hvplot(
             x="Time", y="Counts", shared_axes=False, label=f"{label} (dt={dt})"
         )
+
         if color_key:
-            return hd.rasterize(plot, aggregator=hd.ds.mean("Counts"), color_key=color_key).opts(
-                tools=['hover'], cmap=[color_key], width=600, height=600
-            )
+
+            if rasterize_checkbox.value:
+
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Counts"),
+                    color_key=color_key,
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=True,
+                )
+
+            else:
+
+                return plot
+
         else:
-            return hd.rasterize(plot, aggregator=hd.ds.mean("Counts")).opts(
-                tools=['hover'], width=600, height=600
-            )
+
+            if rasterize_checkbox.value:
+
+                return hd.rasterize(
+                    plot, aggregator=hd.ds.mean("Counts"), line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    colorbar=True,
+                    cmap="Viridis",
+                )
+
+            else:
+
+                return plot
+
+    def create_holoviews_plots_no_colorbar(df, label, dt, color_key=None):
+
+        plot = df.hvplot(
+            x="Time", y="Counts", shared_axes=False, label=f"{label} (dt={dt})"
+        )
+
+        if color_key:
+
+            if rasterize_checkbox.value:
+
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Counts"),
+                    color_key=color_key,
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                )
+
+            else:
+
+                return plot
+
+        else:
+
+            if rasterize_checkbox.value:
+
+                return hd.rasterize(
+                    plot, aggregator=hd.ds.mean("Counts"), line_width=3, pixel_ratio=2
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                    cmap="Viridis",
+                )
+
+            else:
+
+                return plot
 
     def create_dataframe_panes(df, title, dt):
         return pn.FlexBox(
@@ -256,7 +337,8 @@ def create_lightcurve_tab(
 
         # Define a color key for distinct colors
         color_key = {
-            index: colors[i % len(colors)] for i, index in enumerate(selected_event_list_indices)
+            index: colors[i % len(colors)]
+            for i, index in enumerate(selected_event_list_indices)
         }
 
         for index in selected_event_list_indices:
@@ -264,7 +346,7 @@ def create_lightcurve_tab(
             df = create_dataframe(index, dt)
             if df is not None:
                 event_list_name = loaded_event_data[index][0]
-                plot_hv = create_holoviews_plots(
+                plot_hv = create_holoviews_plots_no_colorbar(
                     df, label=event_list_name, dt=dt, color_key=color_key[index]
                 )
                 combined_plots.append(plot_hv)
@@ -272,9 +354,11 @@ def create_lightcurve_tab(
 
         if combined_plots:
             # Use hv.Overlay and add legend manually
-            combined_plot = hv.Overlay(combined_plots).opts(
-                shared_axes=False, legend_position='right', width=600, height=600
-            ).collate()
+            combined_plot = (
+                hv.Overlay(combined_plots)
+                .opts(shared_axes=False, legend_position="right", width=600, height=600)
+                .collate()
+            )
 
             combined_pane = create_holoviews_panes(combined_plot)
 
@@ -318,6 +402,7 @@ def create_lightcurve_tab(
         multi_event_select,
         floatpanel_plots_checkbox,
         dataframe_checkbox,
+        rasterize_checkbox,
         pn.Row(generate_lightcurve_button, show_dataframe_button, combine_plots_button),
     )
     return tab1_content

modules/QuickLook/PowerColors.py

@@ -0,0 +1,137 @@
+import panel as pn
+import holoviews as hv
+from stingray import DynamicalPowerspectrum
+from stingray.power_colors import (
+    hue_from_power_color,
+    plot_power_colors,
+    plot_hues,
+    DEFAULT_COLOR_CONFIGURATION,
+)
+from utils.globals import loaded_event_data
+import warnings
+from utils.DashboardClasses import (
+    MainHeader,
+    MainArea,
+    OutputBox,
+    WarningBox,
+    HelpBox,
+    Footer,
+    WarningHandler,
+    FloatingPlot,
+    PlotsContainer,
+)
+
+# Create a warning handler
+def create_warning_handler():
+    warning_handler = WarningHandler()
+    warnings.showwarning = warning_handler.warn
+    return warning_handler
+
+""" Header Section """
+def create_quicklook_powercolors_header(
+    header_container, main_area_container, output_box_container, warning_box_container, plots_container, help_box_container, footer_container, float_panel_container
+):
+    header_input = pn.widgets.TextInput(name="Heading", value="QuickLook Power Colors")
+    return MainHeader(heading=header_input)
+
+""" Output Box Section """
+def create_loadingdata_output_box(content):
+    return OutputBox(output_content=content)
+
+""" Warning Box Section """
+def create_loadingdata_warning_box(content):
+    return WarningBox(warning_content=content)
+
+""" Main Area Section """
+def create_powercolors_tab(output_box_container, warning_box_container, warning_handler, plots_container, header_container, float_panel_container):
+    event_list_dropdown = pn.widgets.Select(
+        name="Select Event List(s)",
+        options={name: i for i, (name, event) in enumerate(loaded_event_data)},
+    )
+
+    segment_size_input = pn.widgets.IntInput(name="Segment Size", value=256, step=1)
+
+    def create_holoviews_panes(plot):
+        return pn.pane.HoloViews(plot, width=600, height=600, linked_axes=False)
+
+    def generate_powercolors(event=None):
+        if not loaded_event_data:
+            output_box_container[:] = [pn.pane.Markdown("No loaded event data available.")]
+            return
+
+        selected_event_list_index = event_list_dropdown.value
+        if selected_event_list_index is None:
+            output_box_container[:] = [pn.pane.Markdown("No event list selected.")]
+            return
+
+        # Convert EventList to LightCurve
+        event_list = loaded_event_data[selected_event_list_index][1]
+        lightcurve = event_list.to_lc(dt=1 / 256)  # Adjust dt value as needed
+
+        segment_size = segment_size_input.value
+        dynps = DynamicalPowerspectrum(
+            data=lightcurve,
+            segment_size=segment_size,
+            sample_time=1 / segment_size,
+            norm="leahy",
+        )
+
+        dynps_reb = dynps.rebin_by_n_intervals(2, method="average")
+
+        # Calculate power colors
+        p1, p1e, p2, p2e = dynps_reb.power_colors(
+            freq_edges=[1 / 256, 1 / 32, 0.25, 2, 16]
+        )
+
+        # Calculate hues from power colors
+        hues = hue_from_power_color(p1, p2)
+
+        # Plot power colors
+        configuration = DEFAULT_COLOR_CONFIGURATION
+        power_colors_plot = plot_power_colors(p1, p1e, p2, p2e, plot_spans=True, configuration=configuration)
+        hues_plot = plot_hues(hues, p1, p2, plot_spans=True, configuration=configuration)
+
+        # Create HoloViews pane for display
+        power_colors_hv = create_holoviews_panes(power_colors_plot)
+        hues_hv = create_holoviews_panes(hues_plot)
+
+        # Add to floating panel or main area
+        float_panel_container.append(
+            FloatingPlot(title="Power Colors", content=power_colors_hv)
+        )
+        plots_container.append(hues_hv)
+
+    generate_powercolors_button = pn.widgets.Button(name="Generate Power Colors", button_type="primary")
+    generate_powercolors_button.on_click(generate_powercolors)
+
+    tab_content = pn.Column(
+        event_list_dropdown,
+        segment_size_input,
+        pn.Row(generate_powercolors_button),
+    )
+    return tab_content
+
+def create_quicklook_powercolors_main_area(
+    header_container, main_area_container, output_box_container, warning_box_container, plots_container, help_box_container, footer_container, float_panel_container
+):
+    warning_handler = create_warning_handler()
+    tabs_content = {
+        "Power Colors": create_powercolors_tab(
+            output_box_container=output_box_container,
+            warning_box_container=warning_box_container,
+            warning_handler=warning_handler,
+            plots_container=plots_container,
+            header_container=header_container,
+            float_panel_container=float_panel_container,
+        ),
+    }
+    return MainArea(tabs_content=tabs_content)
+
+def create_quicklook_powercolors_area():
+    """
+    Create the plots area for the quicklook power colors tab.
+
+    Returns:
+        PlotsContainer: An instance of PlotsContainer with the plots for the quicklook power colors tab.
+    """
+    return PlotsContainer()

modules/QuickLook/PowerSpectrum.py

@@ -42,17 +42,13 @@ colors = [
     "#9edae5",
 ]
 
-
 # Create a warning handler
 def create_warning_handler():
     warning_handler = WarningHandler()
     warnings.showwarning = warning_handler.warn
     return warning_handler
 
-
 """ Header Section """
-
-
 def create_quicklook_powerspectrum_header(
     header_container,
     main_area_container,
@@ -66,30 +62,17 @@ def create_quicklook_powerspectrum_header(
         name="Heading", value="QuickLook Power Spectrum"
     )
     home_subheading_input = pn.widgets.TextInput(name="Subheading", value="")
-
     return MainHeader(heading=home_heading_input, subheading=home_subheading_input)
 
-
 """ Output Box Section """
-
-
 def create_loadingdata_output_box(content):
     return OutputBox(output_content=content)
 
-
 """ Warning Box Section """
-
-
 def create_loadingdata_warning_box(content):
     return WarningBox(warning_content=content)
 
-
-
-
-
 """ Main Area Section """
-
-
 def create_powerspectrum_tab(
     output_box_container,
     warning_box_container,
@@ -124,23 +107,105 @@ def create_powerspectrum_tab(
     )
 
     floatpanel_plots_checkbox = pn.widgets.Checkbox(
-        name="Add Plot to FloatingPanel", value=False
+        name="Add Plot to FloatingPanel", value=True
     )
 
     dataframe_checkbox = pn.widgets.Checkbox(
         name="Add DataFrame to FloatingPanel", value=False
     )
+    
+    rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
+    
+    # New Checkboxes for Rebinning
+    linear_rebin_checkbox = pn.widgets.Checkbox(name="Linear Rebinning", value=False)
+    log_rebin_checkbox = pn.widgets.Checkbox(name="Logarithmic Rebinning", value=False)
+    rebin_with_original_checkbox = pn.widgets.Checkbox(name="Plot Rebin with Original", value=False)
+
+    # Input for Rebin Size
+    rebin_size_input = pn.widgets.FloatInput(
+        name="Rebin Size",
+        value=0.1,
+        step=0.01,
+        start=0.01,
+        end=100.0,
+    )
 
     def create_holoviews_panes(plot):
         return pn.pane.HoloViews(plot, width=600, height=600, linked_axes=False)
 
     def create_holoviews_plots(df, label, dt, norm, color_key=None):
         plot = df.hvplot(x="Frequency", y="Power", shared_axes=False, label=label)
+
         if color_key:
-            return hd.rasterize(plot, aggregator=hd.ds.mean("Power"), color_key=color_key).opts(tools=['hover'], cmap=[color_key], width=600, height=600)
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Power"),
+                    color_key=color_key,
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=True,
+                )
+            else:
+                return plot
         else:
-            return hd.rasterize(plot, aggregator=hd.ds.mean("Power")).opts(tools=['hover'])
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Power"),
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    cmap="Viridis",
+                    colorbar=True,
+                )
+            else:
+                return plot
 
+    def create_holoviews_plots_no_colorbar(df, label, dt, norm, color_key=None):
+        plot = df.hvplot(x="Frequency", y="Power", shared_axes=False, label=label)
+
+        if color_key:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Power"),
+                    color_key=color_key,
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    cmap=[color_key],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                )
+            else:
+                return plot
+        else:
+            if rasterize_checkbox.value:
+                return hd.rasterize(
+                    plot,
+                    aggregator=hd.ds.mean("Power"),
+                    line_width=3,
+                    pixel_ratio=2,
+                ).opts(
+                    tools=["hover"],
+                    width=600,
+                    height=600,
+                    colorbar=False,
+                    cmap="Viridis",
+                )
+            else:
+                return plot
 
     def create_dataframe_panes(df, title):
         return pn.FlexBox(
@@ -168,8 +233,22 @@ def create_powerspectrum_tab(
             return df, ps
         return None, None
 
-    """ Float Panel """
+    """ Rebin Functionality """
+
+    def rebin_powerspectrum(ps):
+        rebin_size = rebin_size_input.value
+        
+        if linear_rebin_checkbox.value:
+            # Perform linear rebinning
+            rebinned_ps = ps.rebin(rebin_size, method="mean")
+            return rebinned_ps
+        elif log_rebin_checkbox.value:
+            # Perform logarithmic rebinning
+            rebinned_ps = ps.rebin_log(f=rebin_size)
+            return rebinned_ps
+        return None
 
+    """ Float Panel """
 
     def create_floatpanel_area(content, title):
         return FloatingPlot(content=content, title=title)
@@ -226,18 +305,45 @@ def create_powerspectrum_tab(
         dt = dt_input.value
         norm = norm_select.value
         df, ps = create_dataframe(selected_event_list_index, dt, norm)
+        
         if df is not None:
             event_list_name = loaded_event_data[selected_event_list_index][0]
-
             label = f"{event_list_name} (dt={dt}, norm={norm})"
-
-            plot_hv = create_holoviews_plots(df, label, dt, norm)
-            holoviews_output = create_holoviews_panes(plot_hv)
-
+            
+            # Create the original plot
+            original_plot_hv = create_holoviews_plots(df, label, dt, norm)
+
+            # Initialize the holoviews_output variable
+            holoviews_output = original_plot_hv
+            
+            # Rebin the powerspectrum if requested
+            rebinned_ps = rebin_powerspectrum(ps)
+            
+            if rebinned_ps is not None:
+                # Create a DataFrame for the rebinned plot
+                rebinned_df = pd.DataFrame({
+                    "Frequency": rebinned_ps.freq,
+                    "Power": rebinned_ps.power,
+                })
+                rebinned_label = f"Rebinned {event_list_name} (dt={dt}, norm={norm})"
+                rebinned_plot_hv = create_holoviews_plots(rebinned_df, rebinned_label, dt, norm)
+
+                # Check if the user wants to plot rebin with the original
+                if rebin_with_original_checkbox.value:
+                    # Combine the original and rebinned plots using HoloViews
+                    holoviews_output = original_plot_hv * rebinned_plot_hv
+                else:
+                    # Only use the rebinned plot
+                    holoviews_output = rebinned_plot_hv
+
+            # Convert the combined HoloViews object to a pane
+            holoviews_output_pane = create_holoviews_panes(holoviews_output)
+
+            # Append the pane to the appropriate container
             if floatpanel_plots_checkbox.value:
                 float_panel_container.append(
                     create_floatpanel_area(
-                        content=holoviews_output,
+                        content=holoviews_output_pane,
                         title=f"Power Spectrum for {event_list_name} (dt={dt}, norm={norm})",
                     )
                 )
@@ -248,7 +354,7 @@ def create_powerspectrum_tab(
                 plots_container.append(
                     pn.FlexBox(
                         pn.pane.Markdown(markdown_content),
-                        holoviews_output,
+                        holoviews_output_pane,
                         align_items="center",
                         justify_content="center",
                         flex_wrap="nowrap",
@@ -260,6 +366,7 @@ def create_powerspectrum_tab(
                 create_loadingdata_output_box("Failed to create power spectrum.")
             ]
 
+
     def combine_selected_plots(event=None):
         selected_event_list_indices = multi_event_select.value
         if not selected_event_list_indices:
@@ -272,9 +379,9 @@ def create_powerspectrum_tab(
         combined_title = []
 
         # Define a color key for distinct colors
-
         color_key = {
-            index: colors[i % len(colors)] for i, index in enumerate(selected_event_list_indices)
+            index: colors[i % len(colors)]
+            for i, index in enumerate(selected_event_list_indices)
         }
 
         for index in selected_event_list_indices:
@@ -285,17 +392,18 @@ def create_powerspectrum_tab(
                 event_list_name = loaded_event_data[index][0]
 
                 label = f"{event_list_name} (dt={dt}, norm={norm})"
-
-                plot_hv = create_holoviews_plots(
-
+                plot_hv = create_holoviews_plots_no_colorbar(
                     df, label, dt, norm, color_key=color_key[index]
-
                 )
                 combined_plots.append(plot_hv)
                 combined_title.append(event_list_name)
 
         if combined_plots:
-            combined_plot = hv.Overlay(combined_plots).opts(shared_axes=False, legend_position='right', width=600, height=600).collate()
+            combined_plot = (
+                hv.Overlay(combined_plots)
+                .opts(shared_axes=False, legend_position="right", width=600, height=600)
+                .collate()
+            )
 
             combined_pane = create_holoviews_panes(combined_plot)
 
@@ -335,19 +443,21 @@ def create_powerspectrum_tab(
     )
     show_dataframe_button.on_click(show_dataframe)
 
-    tab1_content = pn.Column(
+    tab_content = pn.Column(
         event_list_dropdown,
         dt_input,
         norm_select,
         multi_event_select,
         floatpanel_plots_checkbox,
         dataframe_checkbox,
-        pn.Row(
-            generate_powerspectrum_button, show_dataframe_button, combine_plots_button
-        ),
+        rasterize_checkbox,
+        linear_rebin_checkbox,
+        log_rebin_checkbox,
+        rebin_with_original_checkbox,
+        rebin_size_input,
+        pn.Row(generate_powerspectrum_button, show_dataframe_button, combine_plots_button),
     )
-    return tab1_content
-
+    return tab_content
 
 def create_quicklook_powerspectrum_main_area(
     header_container,
@@ -377,7 +487,6 @@ def create_quicklook_powerspectrum_main_area(
 def create_quicklook_powerspectrum_area():
     """
     Create the plots area for the quicklook lightcurve tab.
-
     Returns:
         PlotsContainer: An instance of PlotsContainer with the plots for the quicklook lightcurve tab.
     """

utils/sidebar.py

@@ -6,7 +6,11 @@ from modules.QuickLook.Bispectrum import (
     create_quicklook_bispectrum_main_area,
     create_quicklook_bispectrum_area,
 )
-
+from modules.QuickLook.PowerColors import (
+    create_quicklook_powercolors_header,
+    create_quicklook_powercolors_main_area,
+    create_quicklook_powercolors_area,
+)
 
 from modules.Home.HomeContent import (
     create_home_header,
@@ -61,7 +65,8 @@ def create_sidebar(
         ("Averaged Power Spectrum", "QuickLookAvgPowerspectra"),
         ("Cross Spectrum", "QuickLookCrossSpectrum"),
         ("Averaged Cross Spectrum", "QuickLookAvgCrossSpectrum"),
-            ("Bispectrum", "QuickLookBispectrum"),
+        ("Bispectrum", "QuickLookBispectrum"),
+        ("Power Colors", "QuickLookPowerColors"),  # New menu item for Power Colors
     ]
 
     # Home Button
@@ -294,6 +299,33 @@ def create_sidebar(
             ]
             plots_container[:] = [create_quicklook_bispectrum_area()]
 
+        elif clicked == "QuickLookPowerColors":
+            header[:] = [
+                create_quicklook_powercolors_header(
+                    header_container=header,
+                    main_area_container=main_area,
+                    output_box_container=output_box,
+                    warning_box_container=warning_box,
+                    plots_container=plots_container,
+                    help_box_container=help_box,
+                    footer_container=footer,
+                    float_panel_container=float_panel_container,  # Ensure this is passed
+                )
+            ]
+            main_area[:] = [
+                create_quicklook_powercolors_main_area(
+                    header_container=header,
+                    main_area_container=main_area,
+                    output_box_container=output_box,
+                    warning_box_container=warning_box,
+                    plots_container=plots_container,
+                    help_box_container=help_box,
+                    footer_container=footer,
+                    float_panel_container=float_panel_container,  # Ensure this is passed
+                )
+            ]
+            plots_container[:] = [create_quicklook_powercolors_area()]
+
 
     quicklook_stingray_button.on_click(handle_quicklook_button_selection)