barsukov 1.3.4__tar.gz → 1.3.7__tar.gz

{barsukov-1.3.4/src/barsukov.egg-info → barsukov-1.3.7}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: barsukov
-Version: 1.3.4
+Version: 1.3.7
 Summary: Experiment Automation Package
-Author-email: Igor Barsukov <igorb@ucr.edu>, Steven Castaneda <scast206@ucr.edu>
+Author-email: Igor Barsukov <igorb@ucr.edu>
+Maintainer-email: Steven Castaneda <scast206@ucr.edu>, Marlon Lopez <mlope589@ucr.edu>
 Project-URL: Homepage, https://barsukov.ucr.edu
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
@@ -11,6 +12,11 @@ Description-Content-Type: text/markdown
 Requires-Dist: pytz>=2014.10
 Requires-Dist: numpy>=1.0.0
 Requires-Dist: scipy>=0.9.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: sympy>=1.2
+Requires-Dist: PyQt5>=5.15
+Requires-Dist: pyqtgraph>=0.13.7
+Requires-Dist: dill>=0.4.0
 
 # Barsukov
 
@@ -27,7 +33,7 @@ Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsuko
 ```bash
 pip install barsukov
 ```
-
+Dependencies: pytz, dill, numpy, scipy, matplotlib, pyvisa, IPython, PyQt5, pyqtgraph
 ## Usage
 
 ```python

{barsukov-1.3.4 → barsukov-1.3.7}/README.md

@@ -13,7 +13,7 @@ Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsuko
 ```bash
 pip install barsukov
 ```
-
+Dependencies: pytz, dill, numpy, scipy, matplotlib, pyvisa, IPython, PyQt5, pyqtgraph
 ## Usage
 
 ```python

{barsukov-1.3.4 → barsukov-1.3.7}/pyproject.toml

@@ -9,10 +9,18 @@ dependencies = [
     "pytz>=2014.10",
     "numpy>=1.0.0",
     "scipy>=0.9.0",
+    "matplotlib>=3.8",
+    "sympy >=1.2",
+    "PyQt5 >=5.15",
+    "pyqtgraph >=0.13.7",
+    "dill >=0.4.0",
 ]
 authors = [
     { name = "Igor Barsukov", email = "igorb@ucr.edu" },
+]
+maintainers = [
     { name = "Steven Castaneda", email = "scast206@ucr.edu" },
+    { name = "Marlon Lopez", email = "mlope589@ucr.edu"},
 ]
 requires-python = ">=3.6"
 description = "Experiment Automation Package"

{barsukov-1.3.4 → barsukov-1.3.7}/src/barsukov/data/Lock_in_emulator.py

@@ -44,16 +44,9 @@ class Lock_in_emulator:
         self.x_plot = self.x_arr(self.t_plot)
 
         self.original_signal = self.signal_arr(self.x_plot)
-        self.expected_signal_num = 0.5 * self.x_amp * np.gradient(self.original_signal, self.x_plot)
+        self.expected_signal = 0.5 * self.x_amp * np.gradient(self.original_signal, self.x_plot)
         self.output_signal = self.signal_output_arr(self.t_plot)
 
-        #Symbolic feature:
-        x, p, w, a = sp.symbols('x p w a')
-        f = a / ((x - p)**2 + w**2)
-        dfdx = sp.diff(f, x)
-        f_prime = sp.lambdify((x, p, w, a), dfdx, 'numpy')
-        self.expected_signal = 0.5 * self.x_amp * f_prime(self.x_plot, 2, 1, 1e-6)
-
         self.fit()
         #self.plot()
 
@@ -165,7 +158,6 @@ class Lock_in_emulator:
             self.axes[0].plot(self.x_plot, self.original_signal, 'r-', label='Original Signal')[0],
             self.axes[1].plot(self.x_plot, self.output_signal, 'b-', label='Demodulated Signal (Lock-In)')[0],
             self.axes[1].plot(self.x_plot, self.expected_signal, 'r-', label='Demodulated Signal (Expected)')[0],
-            self.axes[1].plot(self.x_plot, self.expected_signal_num, 'm-', label='Demodulated Signal (Expected Numerical)')[0],
             self.axes[1].plot(self.x_plot, self.adjusted_signal, 'g-', label=f'Demodulated Signal (Adjusted)\n  Diminish: {self.diminish}\n  Stretch:{self.stretch}\n  Shift: {self.shift}')[0],
         ]
 

{barsukov-1.3.4 → barsukov-1.3.7}/src/barsukov/data/__init__.py

@@ -2,4 +2,5 @@ from . import constants
 from . import noise
 from .fft import *
 from .Change_phase import Change_phase
-from .Lock_in_emulator import Lock_in_emulator
+from .Lock_in_emulator import Lock_in_emulator
+from . import lock_in_emulator_app

barsukov-1.3.7/src/barsukov/data/color_map_app.py

@@ -0,0 +1,127 @@
+import sys
+import os
+import argparse
+import numpy as np
+
+try:
+    from PyQt5 import QtCore, QtWidgets
+except ImportError:
+    from PySide6 import QtCore, QtWidgets
+
+from color_map_core import (
+    DataLoader,
+    DEFAULT_XY_FILE,
+    DEFAULT_Z_FILE,
+    DEFAULT_CMAP
+)
+
+from color_map_widget import InteractiveHeatmapWidget
+
+
+def build_arg_parser():
+    """Build command line argument parser"""
+    p = argparse.ArgumentParser(
+        description="Interactive heatmap viewer (CSV/TSV/space-delimited supported)."
+    )
+    p.add_argument("--xy", dest="xy_file", default=DEFAULT_XY_FILE,
+                   help="Path to XY file (X,Y vectors; header optional).")
+    p.add_argument("--z", dest="z_file", default=DEFAULT_Z_FILE,
+                   help="Path to Z matrix file (rows form image lines).")
+    p.add_argument("--x-col", type=int, default=1,
+                   help="Zero-based column index to use for X (default: 1).")
+    p.add_argument("--y-col", type=int, default=0,
+                   help="Zero-based column index to use for Y (default: 0).")
+    p.add_argument("--cmap", default=DEFAULT_CMAP,
+                   help="Colormap to use (e.g., viridis, plasma, inferno, magma, cividis, gray, jet).")
+    return p
+
+
+def main():
+    """Main CLI entry point"""
+    # Parse command line arguments
+    parser = build_arg_parser()
+    args = parser.parse_args()
+    
+    # Load data with data loader
+    loader = DataLoader()
+    
+    # Use command line arguments
+    xy_file = args.xy_file
+    z_file = args.z_file
+    x_col = args.x_col
+    y_col = args.y_col
+    cmap = args.cmap
+    
+    try:
+        # Check if file exists and detect columns
+        if os.path.exists(xy_file):
+            num_cols, col_names = loader.detect_columns(xy_file)
+            if num_cols > 0:
+                # Load with specified columns
+                y, x = loader.load_xy_data(xy_file, x_col=x_col, y_col=y_col)
+                # Use column names for labels if available
+                if col_names and len(col_names) > max(x_col, y_col):
+                    x_label = f'X ({col_names[x_col]})'
+                    y_label = f'Y ({col_names[y_col]})'
+                else:
+                    x_label = 'X'
+                    y_label = 'Y'
+            else:
+                raise ValueError("No columns detected")
+        else:
+            raise FileNotFoundError(f"{xy_file} not found")
+            
+        Z = loader.load_matrix_data(z_file)
+    except Exception as e:
+        print(f"Error loading files: {e}")
+        print("Creating demo data...")
+        # Create demo data if files not found
+        x = np.linspace(0, 10, 100)
+        y = np.linspace(0, 10, 100)
+        xx, yy = np.meshgrid(x, y)
+        Z = np.sin(xx) * np.cos(yy)
+        x_label = 'X'
+        y_label = 'Y'
+    
+    # Calculate ranges
+    xmin, xmax = float(np.nanmin(x)), float(np.nanmax(x))
+    ymin, ymax = float(np.nanmin(y)), float(np.nanmax(y))
+    
+    # Create the app
+    app = QtWidgets.QApplication.instance()
+    created_app = False
+    if app is None:
+        app = QtWidgets.QApplication(sys.argv)
+        created_app = True
+        # Enable high DPI support
+        try:
+            app.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
+            app.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, True)
+        except:
+            pass  # Older Qt version
+    
+    # Initial vmin/vmax from data
+    vmin = float(np.nanmin(Z))
+    vmax = float(np.nanmax(Z))
+    
+    # Create widget
+    win = InteractiveHeatmapWidget(
+        data=Z,
+        x_range=(xmin, xmax),
+        y_range=(ymin, ymax),
+        x_label=x_label,
+        y_label=y_label,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax
+    )
+    
+    win.show()
+    
+    # For CLI, run the event loop
+    if created_app:
+        sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()

barsukov-1.3.7/src/barsukov/data/color_map_core.py

@@ -0,0 +1,283 @@
+"""
+Core computation and data handling for color map analysis
+"""
+import re
+import numpy as np
+
+# ---------------------------
+# CONSTANTS
+# ---------------------------
+DEFAULT_XY_FILE = "table1.txt"
+DEFAULT_Z_FILE = "table2.txt"
+DEFAULT_KC = -0.01
+DEFAULT_KB = 0.002
+DEFAULT_CMAP = 'viridis'
+
+
+# ---------------------------
+# DATA I/O
+# ---------------------------
+class DataLoader:
+    """Handles file I/O operations for XY and matrix data"""
+    
+    @staticmethod
+    def detect_columns(path):
+        """Detect the number and names of columns in a data file"""
+        try:
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                # Read header line
+                header = f.readline().strip()
+                
+                # Read first data line to determine actual column count
+                first_data_line = None
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        first_data_line = line
+                        break
+                
+                # Determine delimiter from first data line (more reliable)
+                if first_data_line:
+                    if '\t' in first_data_line:
+                        delim = '\t'
+                        splitter = re.compile(r'\t+')
+                    elif ',' in first_data_line:
+                        delim = ','
+                        splitter = re.compile(r',')
+                    else:
+                        delim = None
+                        splitter = re.compile(r'\s+')
+                    
+                    # Count columns in data line
+                    data_parts = [p for p in splitter.split(first_data_line) if p.strip()]
+                    num_cols = len(data_parts)
+                    
+                    # Parse header if present
+                    if header:
+                        header_parts = [p.strip() for p in splitter.split(header) if p.strip()]
+                        # Check if header contains numbers (likely not a header)
+                        try:
+                            float(header_parts[0])
+                            # First line is data, not header
+                            return num_cols, [f"Column {i}" for i in range(num_cols)]
+                        except:
+                            # First line is header, but might have fewer columns
+                            # Use actual data column count
+                            col_names = header_parts[:num_cols]
+                            # Pad with generic names if header has fewer columns
+                            while len(col_names) < num_cols:
+                                col_names.append(f"Column {len(col_names)}")
+                            return num_cols, col_names
+                    else:
+                        return num_cols, [f"Column {i}" for i in range(num_cols)]
+                
+                # Fallback: try to parse header
+                if header:
+                    parts = re.split(r'[,\t\s]+', header)
+                    parts = [p.strip() for p in parts if p.strip()]
+                    try:
+                        float(parts[0])
+                        return len(parts), [f"Column {i}" for i in range(len(parts))]
+                    except:
+                        return len(parts), parts
+                
+                return 0, []
+        except:
+            return 0, []
+    
+    @staticmethod
+    def load_xy_data(path, x_col=1, y_col=0):
+        """Load X/Y data with column selection
+        
+        Uses np.genfromtxt to handle missing values gracefully (converts to NaN).
+        This matches legacy behavior where missing first column values become NaN in y,
+        but the rest of the row still contributes to x.
+        """
+        delim = None  # Initialize delim before try block
+        skip_header = 0
+        
+        # First detect delimiter and header from first data line (more reliable)
+        try:
+            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                first_line = f.readline().strip()
+                
+                # Check if first line is header by trying to parse first element as float
+                try:
+                    # Try to parse first element as number
+                    float(first_line.split()[0].strip())
+                    skip_header = 0
+                    # First line is data, use it for delimiter detection
+                    test_line = first_line
+                except (ValueError, IndexError):
+                    # First line is likely header, read next line for delimiter detection
+                    skip_header = 1
+                    test_line = None
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#'):
+                            test_line = line
+                            break
+                
+                # Detect delimiter from actual data line (more reliable)
+                if test_line:
+                    if '\t' in test_line:
+                        delim = '\t'
+                    elif ',' in test_line:
+                        delim = ','
+                    else:
+                        delim = None  # whitespace
+        except:
+            pass
+        
+        # Try np.loadtxt first (faster for well-formed data)
+        try:
+            data = np.loadtxt(path, skiprows=skip_header, dtype=np.float64, ndmin=2, delimiter=delim)
+            if data.size == 0:
+                raise ValueError("No data found in file")
+            
+            # Handle single column case
+            if data.ndim == 1:
+                data = data.reshape(-1, 1)
+            
+            # Validate column indices
+            num_cols = data.shape[1]
+            if x_col >= num_cols:
+                x_col = min(x_col, num_cols - 1)
+            if y_col >= num_cols:
+                y_col = min(y_col, num_cols - 1)
+            
+            return data[:, y_col], data[:, x_col]  # y, x
+        except (ValueError, IndexError, UnicodeDecodeError):
+            # np.loadtxt failed (likely due to missing values), fall back to np.genfromtxt
+            # np.genfromtxt handles missing values by converting them to NaN
+            pass
+        
+        # Use np.genfromtxt (handles missing values gracefully)
+        # If delim wasn't set, try to detect it from first data line
+        if delim is None:
+            try:
+                with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                    # Skip header
+                    first_line = f.readline().strip()
+                    try:
+                        float(first_line.split()[0].strip())
+                        test_line = first_line
+                        skip_header = 0
+                    except (ValueError, IndexError):
+                        skip_header = 1
+                        test_line = None
+                        for line in f:
+                            line = line.strip()
+                            if line and not line.startswith('#'):
+                                test_line = line
+                                break
+                    
+                    if test_line:
+                        if '\t' in test_line:
+                            delim = '\t'
+                        elif ',' in test_line:
+                            delim = ','
+                        else:
+                            delim = None
+            except:
+                delim = None
+        
+        # Use np.genfromtxt which handles missing values (converts to NaN)
+        # This matches legacy behavior: missing first column -> NaN in y, but row still contributes to x
+        try:
+            y, x = np.genfromtxt(
+                path,
+                delimiter=delim,
+                dtype=np.float64,
+                skip_header=skip_header,
+                usecols=(y_col, x_col),
+                unpack=True,
+                autostrip=True,
+                invalid_raise=False,  # Don't raise on invalid values, convert to NaN
+            )
+            return y, x
+        except Exception:
+            # If all else fails, try default columns
+            y, x = np.genfromtxt(
+                path,
+                delimiter=delim,
+                dtype=np.float64,
+                skip_header=skip_header,
+                usecols=(0, 1),
+                unpack=True,
+                autostrip=True,
+                invalid_raise=False,
+            )
+            return y, x
+    
+    @staticmethod
+    def load_matrix_data(path):
+        """Optimized matrix loading with better memory usage"""
+        # First pass: determine dimensions
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            lines = [line.strip() for line in f if line.strip() and not line.strip().startswith("#")]
+        
+        if not lines:
+            raise ValueError("No numeric rows found in file")
+        
+        first = lines[0]
+        if ',' in first:
+            sep = ','
+            splitter = re.compile(r"\s*,\s*")
+        elif '\t' in first:
+            sep = '\t'
+            splitter = re.compile(r"\t+")
+        else:
+            sep = ' '  # whitespace
+            splitter = re.compile(r"\s+")
+
+        rows = []
+        for line in lines:
+            try:
+                row = np.fromstring(line, sep=sep, dtype=np.float64)
+                if row.size:
+                    rows.append(row)
+                    continue
+            except Exception:
+                pass
+            # Fallback parser (handles stray spaces/commas)
+            parts = [p for p in splitter.split(line) if p]
+            vals = []
+            for p in parts:
+                try:
+                    vals.append(float(p))
+                except ValueError:
+                    pass
+            if vals:
+                rows.append(np.asarray(vals, dtype=np.float64))
+
+        if not rows:
+            raise ValueError("No numeric rows found in file")
+
+        widths = np.array([r.size for r in rows], dtype=int)
+        modal_w = np.bincount(widths).argmax()
+        good_rows = [r for r in rows if r.size == modal_w]
+        A = np.vstack(good_rows).astype(np.float64)
+        if A.shape[0] > A.shape[1]:
+            A = A.T
+        return A
+
+
+# ---------------------------
+# COMPUTATION UTILITIES
+# ---------------------------
+def calculate_effective_range(vmin, vmax, brightness, contrast):
+    """Calculate effective value range after brightness/contrast adjustment"""
+    vmin_p = (vmin - brightness) / max(1e-12, contrast)
+    vmax_p = (vmax - brightness) / max(1e-12, contrast)
+    return vmin_p, vmax_p
+
+
+def calculate_marker_position(brightness, contrast, span, kc=DEFAULT_KC):
+    """Calculate control pad marker position from brightness/contrast values"""
+    import math
+    u = np.clip(0.5 + brightness / max(1e-9, span), 0.0, 1.0)
+    v = 0.5
+    if contrast > 0:
+        v = np.clip(0.5 - math.log(contrast) / (2 * max(1e-9, abs(kc))), 0.0, 1.0)
+    return u, v