specula 0.0.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

specula/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = 'gd50bd1fba'

specula/display/base_display.py

@@ -0,0 +1,99 @@
+from specula.base_processing_obj import BaseProcessingObj
+import matplotlib.pyplot as plt
+
+
+class BaseDisplay(BaseProcessingObj):
+    def __init__(self,
+                 title='',
+                 figsize=(8, 6)):
+        super().__init__()
+        self._title = title
+        self._figsize = figsize
+        self._opened = False
+        self._colorbar_added = False
+        self.input_key = ''
+        self.fig = None
+        self.ax = None
+        self.img = None
+        self.line = None
+
+    def _create_figure(self):
+        """Create the matplotlib figure and axes"""
+        if self._opened:
+            return
+
+        self.fig = plt.figure(figsize=self._figsize)
+        self.ax = self.fig.add_subplot(111)
+        if self._title:
+            self.fig.suptitle(self._title)
+        self.fig.show()
+        self._opened = True
+
+    def _update_display(self, data):
+        """Update the display with new data"""
+        raise NotImplementedError("Subclasses should implement this method")
+
+    def _get_data(self):
+        """Get data from input. Derived classes can override this method
+        in case of complex data"""
+        data = self.local_inputs.get(self.input_key)
+        if data is None:
+            self._show_error(f"No {self.input_key} data available")
+            return
+        return data
+
+    def trigger_code(self):
+        try:
+            if not self._opened:
+                self._create_figure()
+            data = self._get_data()
+            self._update_display(data)
+        except Exception as e:
+            self._show_error(f"Display error: {str(e)}")
+
+    # ============ UTILITY METHODS ============
+
+    def set_y_range(self, ymin, ymax):
+        """Set fixed Y axis range"""
+        if hasattr(self, '_yrange'):
+            self._yrange = (ymin, ymax)
+            if self._opened and self.ax:
+                self.ax.set_ylim(ymin, ymax)
+                self._safe_draw()
+
+    def auto_y_range(self):
+        """Enable automatic Y axis scaling - override in subclasses for specific logic"""
+        if hasattr(self, '_yrange'):
+            self._yrange = (0, 0)
+
+    def _add_colorbar_if_needed(self, image_obj):
+        """Add colorbar if not already present"""
+        if not hasattr(self, '_colorbar_added'):
+            self._colorbar_added = False
+
+        if not self._colorbar_added and image_obj is not None:
+            plt.colorbar(image_obj, ax=self.ax)
+            self._colorbar_added = True
+
+    def _update_image_data(self, image_obj, data):
+        """Standard image update logic"""
+        if image_obj is not None:
+            image_obj.set_data(data)
+            image_obj.set_clim(data.min(), data.max())
+
+    def _show_error(self, message):
+        if not self._opened:
+            self._create_figure()
+        self.ax.clear()
+        self.ax.text(0.5, 0.5, message, ha='center', va='center', 
+                    transform=self.ax.transAxes, color='red', fontsize=12)
+        self._safe_draw()
+
+    def _safe_draw(self):
+        """Thread-safe drawing method"""
+        try:
+            if self.fig and self.fig.canvas:
+                self.fig.canvas.draw_idle()
+                self.fig.canvas.flush_events()
+        except Exception as e:
+            print(f"Drawing error: {e}")

specula/display/data_plotter.py

@@ -0,0 +1,177 @@
+
+import matplotlib
+import numpy as np
+matplotlib.use('Agg') # Memory backend, no GUI
+
+from matplotlib.figure import Figure
+
+dataplotter_cache = {}
+
+class DataPlotter():
+    '''
+    Plot any kind of data in a memory backend
+    '''
+    def __init__(self, disp_factor=1, histlen=200, wsize=(400, 300), yrange=(-10, 10), title=''):
+        super().__init__()
+
+        self._wsize = wsize
+        self._history = np.zeros(histlen)
+        self._count = 0
+        self._yrange = yrange
+        self._value = None
+        self._title = title
+        self._w_is_set = False
+        self._first = True
+        self._disp_factor = disp_factor
+
+    def set_w(self, size_frame=None, nframes=1):
+        if self._w_is_set:
+            return
+
+        if size_frame is None:
+            size_frame = self._wsize
+        self.fig = Figure(figsize=(size_frame[0] * self._disp_factor / 100 * nframes, size_frame[1] * self._disp_factor / 100))
+        self.ax = []
+        for i in range(nframes):
+            self.ax.append(self.fig.add_subplot(1, nframes, i+1))
+        self.fig.subplots_adjust(hspace=0.1, wspace=0.1)  # Adjust these values as needed
+  
+        self._w_is_set = True
+
+    def multi_plot(self, obj_list):
+        '''
+        Plot a list of data objects one next to the other.
+        
+        Returns a matplotlib.Figure object.
+        
+        Generation of the numpy array to display is delegated to each data object.
+        '''
+
+        if obj_list is None:
+            return self.plot_text(f'This is None')
+
+        if len(obj_list) < 1:
+            return self.plot_text(f'No values to plot')
+
+#        TODO: commented out because it does not work for prop.layer_list,
+#        since layers are of different types
+#
+#        for obj in objrefs[1:]:
+#            if type(obj) is not type(objrefs[0]):
+#                raise ValueError('All objects in multi_plot() must be of the same type')
+
+        if not hasattr(obj_list[0], 'array_for_display'):
+            return self.plot_text(f'Plot not implemented for class {obj_list[0].__class__.__name__}')
+
+        frames = [x.array_for_display() for x in obj_list]
+
+        for f in frames:
+            if f is None:
+                return self.plot_text(f'Cannot plot None values')
+
+        # 2d images: imshow
+        if len(frames[0].shape) == 2:
+            return self.imshow(frames)
+
+        # Single vector value: plot_vector
+        elif len(frames[0].shape) == 1 and len(frames[0]) > 1 and len(frames) == 1:
+            return self.plot_vector(frames[0])
+
+        # Scalar value: plot history
+        elif len(frames[0].shape) == 1 and len(frames[0]) == 1 and len(frames) == 1:
+            return self.plot_history(frames[0])
+
+        # Another kind of scalar value: plot history
+        elif len(frames[0].shape) == 0 and len(frames) == 1:
+            return self.plot_history(frames[0])
+
+        else:
+            return self.plot_text(f'Cannot plot: data shape is {frames[0].shape} x {len(frames)}')
+
+    def plot_history(self, value):
+        n = len(self._history)
+        if self._count >= n:
+            self._history[:-1] = self._history[1:]
+            self._count = n - 1
+
+        self.set_w()
+        self._history[self._count] = value
+        self._count += 1
+
+        x = np.arange(self._count)
+        y = self._history[:self._count]
+        if self._first:
+            self.fig.suptitle(self._title)
+            self.line = self.ax[0].plot(x, y, marker='.')
+            self._first = False
+        else:
+            self.line[0].set_xdata(x)
+            self.line[0].set_ydata(y)
+            self.ax[0].set_xlim(x.min(), x.max())
+            self.ax[0].set_ylim(y.min(), y.max())
+        self.fig.canvas.draw()
+        return self.fig
+
+    def plot_vector(self, vector):
+        self.set_w()
+
+        if self._first:
+            self._line = self.ax[0].plot(vector, '.-')
+            self.fig.suptitle(self._title)
+            self.ax[0].set_ylim([vector.min(), vector.max()])
+            self._first = False
+        else:
+            self._line[0].set_ydata(vector)
+        return self.fig
+
+    def imshow(self, frames):
+        if np.sum(self._wsize) == 0:
+            size_frame = frames[0].shape[0]
+        else:
+            size_frame = self._wsize
+
+        self.set_w(size_frame, len(frames))
+
+        if self._first:
+            self.img = []
+            for i, frame in enumerate(frames):
+                self.img.append(self.ax[i].imshow(frame))
+            self._first = False
+        else:
+            for i, frame in enumerate(frames):
+                self.img[i].set_data(frame)
+                self.img[i].set_clim(frame.min(), frame.max())
+        self.fig.canvas.draw()
+        return self.fig
+
+    def plot_text(self, text):
+        self.set_w()
+
+        if self._first:
+            self.text = self.ax[0].text(0, 0, text, fontsize=14)
+        else:
+            del self.text
+            self.text = self.ax[0].text(0, 0, text, fontsize=14)
+        self.fig.canvas.draw()
+        return self.fig
+
+
+    @staticmethod
+    def plot_best_effort(plot_name, dataobj_or_list):
+        '''
+        Plot a data object or a list of data objects as best as it can be done.
+        The plot_name is used to remember the DataPlotter instance and allow
+        plot updates instead of expensive re-plots from scratch
+        '''
+
+        if plot_name not in dataplotter_cache:
+            dataplotter_cache[plot_name] = DataPlotter()
+
+        if isinstance(dataobj_or_list, list):
+            for obj in dataobj_or_list:
+                obj.xp = np
+            fig = dataplotter_cache[plot_name].multi_plot(dataobj_or_list)
+        else:
+            dataobj_or_list.xp = np  # Supply a numpy instance, sometimes it is needed
+            fig = dataplotter_cache[plot_name].multi_plot([dataobj_or_list])
+        return fig

specula/display/double_phase_display.py

@@ -0,0 +1,142 @@
+import numpy as np
+
+from specula import cpuArray
+
+from specula.display.base_display import BaseDisplay
+from specula.connections import InputValue
+from specula.data_objects.electric_field import ElectricField
+
+from symao.turbolence import ft_ft2
+
+
+class DoublePhaseDisplay(BaseDisplay):
+    def __init__(self,
+                 title='Double Phase Display',
+                 figsize=(12, 3)):  # 4 subplots side by side
+
+        super().__init__(
+            title=title,
+            figsize=figsize
+        )
+
+        self.img1 = None
+        self.img2 = None
+        self.nframes = 0
+        self.psd_statTot1 = None
+        self.psd_statTot2 = None
+
+        # Setup inputs - two phase inputs
+        self.inputs['phase1'] = InputValue(type=ElectricField)
+        self.inputs['phase2'] = InputValue(type=ElectricField)
+
+    def _process_phase_data(self, phase):
+        """Process phase data: mask and remove average"""
+        frame = cpuArray(phase.phaseInNm * (phase.A > 0).astype(float))
+
+        # Get valid indices (where amplitude > 0)
+        valid_mask = cpuArray(phase.A) > 0
+
+        if np.any(valid_mask):
+            # Remove average phase only from valid pixels
+            frame[valid_mask] -= np.mean(frame[valid_mask])
+
+            if self.verbose:
+                print('Removing average phase in double_phase_display')
+
+        return frame
+
+    def _calculate_psd(self, frame):
+        """Calculate power spectral density"""
+        return np.absolute(ft_ft2(frame, 1))**2
+
+    def _get_data(self):
+        """Get both phases"""
+        phase1 = self.local_inputs.get('phase1')
+        phase2 = self.local_inputs.get('phase2')
+
+        if phase1 is None or phase2 is None:
+            return []  # BaseDisplay will show error
+
+        return [phase1, phase2]
+
+    def _update_display(self, data_list):
+        """Override base method - now receives list of [phase1, phase2]"""
+        if len(data_list) != 2:
+            self._show_error("Need both phase1 and phase2 inputs")
+            return
+
+        phase1, phase2 = data_list
+
+        # Process both phases
+        frame1 = self._process_phase_data(phase1)
+        frame2 = self._process_phase_data(phase2)
+
+        # Calculate PSDs
+        psd_stat1 = self._calculate_psd(frame1)
+        psd_stat2 = self._calculate_psd(frame2)
+        ss = frame1.shape[0]
+
+        # Update frame counter and accumulate PSDs
+        self.nframes += 1
+
+        if self.psd_statTot1 is None:
+            self.psd_statTot1 = np.zeros_like(psd_stat1)
+        if self.psd_statTot2 is None:
+            self.psd_statTot2 = np.zeros_like(psd_stat2)
+
+        self.psd_statTot1 = (self.psd_statTot1 * (self.nframes-1) + psd_stat1) / self.nframes
+        self.psd_statTot2 = (self.psd_statTot2 * (self.nframes-1) + psd_stat2) / self.nframes
+
+        # Create subplots on first run
+        if self.img1 is None:
+            # Clear default axis and create 4 subplots
+            self.fig.clear()
+            self.ax1 = self.fig.add_subplot(141)
+            self.ax2 = self.fig.add_subplot(142)
+            self.ax3 = self.fig.add_subplot(143)
+            self.ax4 = self.fig.add_subplot(144)
+
+            # Create images
+            self.img1 = self.ax1.imshow(frame1)
+            self.img2 = self.ax2.imshow(frame2)
+
+            # Set titles
+            self.ax1.set_title('Phase 1')
+            self.ax2.set_title('Phase 2')
+            self.ax3.set_title('PSD Instantaneous')
+            self.ax4.set_title('PSD Average')
+        else:
+            # Update existing images
+            self.img1.set_data(frame1)
+            self.img1.set_clim(frame1.min(), frame1.max())
+            self.img2.set_data(frame2)
+            self.img2.set_clim(frame2.min(), frame2.max())
+
+        # Clear and update PSD plots
+        self.ax3.clear()
+        self.ax4.clear()
+
+        # Plot instantaneous PSDs with low alpha
+        self.ax3.loglog(psd_stat1[ss//2, ss//2+1:], alpha=0.025, color='r', label='Phase 1')
+        self.ax3.loglog(psd_stat2[ss//2, ss//2+1:], alpha=0.025, color='b', label='Phase 2')
+        self.ax3.set_title('PSD Instantaneous')
+        self.ax3.legend()
+
+        # Plot averaged PSDs
+        self.ax4.loglog(self.psd_statTot1[ss//2, ss//2+1:], color='r', label='Phase 1')
+        self.ax4.loglog(self.psd_statTot2[ss//2, ss//2+1:], color='b', label='Phase 2')
+        self.ax4.set_title(f'PSD Average (n={self.nframes})')
+        self.ax4.legend()
+
+        self._safe_draw()
+
+    def trigger_code(self):
+        """Override to handle dual phase inputs"""
+        try:
+            if not self._opened:
+                self._create_figure()
+
+            # DoublePhaseDisplay handles dual inputs
+            self._update_display()
+        except Exception as e:
+            self._show_error(f"Double phase display error: {str(e)}")

specula/display/modes_display.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+from specula.display.base_display import BaseDisplay
+from specula.connections import InputValue
+from specula.base_value import BaseValue
+from specula import cpuArray
+
+
+class ModesDisplay(BaseDisplay):
+    def __init__(self, 
+                 title='Modes Display',
+                 figsize=(6, 3),
+                 xrange=None,
+                 yrange=(-500, 500)):
+
+        super().__init__(
+            title=title,
+            figsize=figsize
+        )
+
+        self._xrange = xrange
+        self._yrange = yrange
+        self.line = None
+
+        # Setup input
+        self.input_key = 'modes' # Used by base class
+        self.inputs['modes'] = InputValue(type=BaseValue)
+
+    def _update_display(self, modes):
+        """Override base method to implement modes-specific display"""
+        # Get the modes vector
+        y = cpuArray(modes.value)
+        x = np.arange(len(y))
+
+        if self.line is None:
+            # First time: create line
+            self.line = self.ax.plot(x, y, '.-')[0]
+
+            # Set fixed X range if specified
+            if self._xrange is not None:
+                self.ax.set_xlim(self._xrange[0], self._xrange[1])
+            elif len(x) > 0:
+                self.ax.set_xlim(0, len(x) - 1)
+
+            # Set fixed Y range if specified
+            if np.sum(np.abs(self._yrange)) > 0:
+                self.ax.set_ylim(self._yrange[0], self._yrange[1])
+            else:
+                # Auto-scale based on data
+                self.ax.set_ylim(y.min() * 1.1, y.max() * 1.1)
+
+            # Add reference line at y=0
+            self.ax.axhline(y=0, color='grey', linestyle='--',
+                          dashes=(4, 8), linewidth=0.5, alpha=0.7)
+
+            # Set labels
+            self.ax.set_xlabel('Mode Index')
+            self.ax.set_ylabel('Mode Value')
+        else:
+            # Update existing line
+            self.line.set_xdata(x)
+            self.line.set_ydata(y)
+
+            # Update X limits if vector size changed or xrange is set
+            if self._xrange is not None:
+                self.ax.set_xlim(self._xrange[0], self._xrange[1])
+            elif len(x) > 0:
+                self.ax.set_xlim(0, len(x) - 1)
+
+            # Update Y limits if auto-scaling
+            if np.sum(np.abs(self._yrange)) == 0:
+                self.ax.set_ylim(y.min() * 1.1, y.max() * 1.1)
+
+        # Draw efficiently
+        self._safe_draw()
+
+    def set_x_range(self, xmin, xmax):
+        """Set fixed X axis range"""
+        self._xrange = (xmin, xmax)
+        if self.line is not None:
+            self.ax.set_xlim(xmin, xmax)
+            self._safe_draw()
+
+    def set_y_range(self, ymin, ymax):
+        """Set fixed Y axis range"""
+        self._yrange = (ymin, ymax)
+        if self.line is not None:
+            self.ax.set_ylim(ymin, ymax)
+            self._safe_draw()

specula/display/phase_display.py

@@ -0,0 +1,48 @@
+
+import numpy as np
+
+from specula import cpuArray
+
+from specula.display.base_display import BaseDisplay
+from specula.connections import InputValue
+from specula.data_objects.electric_field import ElectricField
+
+class PhaseDisplay(BaseDisplay):
+    def __init__(self,
+                 title='Phase Display',
+                 figsize=(8, 6)):  # Default size in inches
+        super().__init__(
+            title=title,
+            figsize=figsize
+        )
+
+        # Setup input
+        self.input_key = 'phase'  # Used by base class
+        self.inputs['phase'] = InputValue(type=ElectricField)
+
+    def _process_phase_data(self, phase):
+        """Process phase data: mask and remove average"""
+        frame = cpuArray(phase.phaseInNm * (phase.A > 0).astype(float))
+
+        # Get valid indices (where amplitude > 0)
+        valid_mask = cpuArray(phase.A) > 0
+
+        if np.any(valid_mask):
+            # Remove average phase only from valid pixels
+            frame[valid_mask] -= np.mean(frame[valid_mask])
+
+            if self.verbose:
+                print('Removing average phase in phase_display')
+
+        return frame
+
+    def _update_display(self, phase):
+        frame = self._process_phase_data(phase)
+
+        if self.img is None:
+            self.img = self.ax.imshow(frame)
+            self._add_colorbar_if_needed(self.img)
+        else:
+            self._update_image_data(self.img, frame)
+
+        self._safe_draw()