structured-optics 0.4__tar.gz → 0.4.1__tar.gz

{structured_optics-0.4 → structured_optics-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.4
+Version: 0.4.1
 Summary: Package for Structured Light simulation
 Author: Altilano C. Barbosa
 License-Expression: BSD-3-Clause
@@ -9,7 +9,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
-Requires-Dist: PyQt6
+Requires-Dist: screeninfo
 Dynamic: license-file
 
 # structured-optics
@@ -75,7 +75,7 @@ Soon...
 - Python 3.9+
 - numpy
 - scipy
-- PyQt6
+- screeninfo
 
 
 

{structured_optics-0.4 → structured_optics-0.4.1}/README.md

@@ -61,7 +61,7 @@ Soon...
 - Python 3.9+
 - numpy
 - scipy
-- PyQt6
+- screeninfo
 
 
 

{structured_optics-0.4 → structured_optics-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structured_optics"
-version = "0.4"
+version = "0.4.1"
 description = "Package for Structured Light simulation"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -16,5 +16,5 @@ authors = [
 dependencies = [
     "numpy",
     "scipy",
-    "PyQt6"
+    "screeninfo"
 ]

structured_optics-0.4.1/structured_optics/slmdisplay.py

@@ -0,0 +1,160 @@
+"""import sys
+import numpy as np
+from PyQt6.QtWidgets import QApplication, QLabel
+from PyQt6.QtGui import QImage, QPixmap
+from PyQt6.QtCore import Qt
+
+class My_SLM(QLabel):
+    def __init__(self, screen_index=0):
+        self.app = QApplication.instance() or QApplication(sys.argv)
+        super().__init__()
+
+        screens = self.app.screens()
+        if screen_index >= len(screens):
+            raise ValueError("Invalid screen index")
+
+        screen = screens[screen_index]
+
+        # Force native window creation (CRITICAL on Linux)
+        self.setAttribute(Qt.WidgetAttribute.WA_NativeWindow)
+
+        self.setWindowFlags(
+            Qt.WindowType.FramelessWindowHint
+        )
+
+        self.show()  # must come before windowHandle()
+
+        self.windowHandle().setScreen(screen)
+        geo = screen.geometry()
+
+        # Store logical screen size
+        self.width = geo.width()
+        self.height = geo.height()
+        self.setGeometry(geo)
+
+        self.showFullScreen()
+
+        self._img_ref = None
+
+
+    def update_image(self, img: np.ndarray):
+        
+        #img:
+        #  - (H, W) uint8 → grayscale
+        #  - (H, W, 3) uint8 → RGB
+        
+        if img.dtype != np.uint8:
+            raise TypeError("Image must be uint8")
+
+        self._img_ref = img  # keep reference alive
+
+        if img.ndim == 2:
+            h, w = img.shape
+            stride = img.strides[0]
+
+            qimg = QImage(
+                img.data,
+                w,
+                h,
+                stride,
+                QImage.Format.Format_Grayscale8
+            )
+
+        elif img.ndim == 3 and img.shape[2] == 3:
+            h, w, _ = img.shape
+            stride = img.strides[0]
+
+            qimg = QImage(
+                img.data,
+                w,
+                h,
+                stride,
+                QImage.Format.Format_RGB888
+            )
+        else:
+            raise ValueError("Image must be (H,W) or (H,W,3)")
+
+        self.setPixmap(QPixmap.fromImage(qimg))
+        self.app.processEvents()
+
+    def close(self):
+        if not self.isVisible():
+            return
+        self.hide()
+        self.setParent(None)   # detach from Qt ownership
+        self.deleteLater() """
+
+import tkinter as tk
+import numpy as np
+from screeninfo import get_monitors
+
+
+class My_SLM:
+    """
+    Fullscreen numpy-array display on a chosen physical monitor.
+    Uses plain tkinter (stdlib) - the image is shown as ordinary
+    CPU-composited window content, the same way PyQt6's QLabel/QPixmap
+    did. Unlike an OpenGL surface (pyglet/GLFW), this never becomes a
+    GPU flip-model surface, so it doesn't trigger the driver-level
+    scanout switch that causes the display to briefly flash/resync.
+    """
+
+    def __init__(self, screen_index: int = 0):
+        monitors = get_monitors()
+        if screen_index >= len(monitors):
+            raise ValueError("Invalid screen index")
+
+        m = monitors[screen_index]
+        self.width, self.height = m.width, m.height
+
+        self.root = tk.Tk()
+        self.root.overrideredirect(True)  # borderless
+        self.root.geometry(f"{self.width}x{self.height}+{m.x}+{m.y}")
+        self.root.attributes("-topmost", True)
+        self.root.configure(bg="black")
+
+        self.label = tk.Label(self.root, bd=0, highlightthickness=0, bg="black")
+        self.label.pack(fill="both", expand=True)
+
+        self.root.update_idletasks()
+        self.root.update()
+
+        self._photo_ref = None  # keep the PhotoImage alive (Tk drops it otherwise)
+        self._img_ref = None
+
+    def update_image(self, img: np.ndarray):
+        """
+        img:
+          - (H, W) uint8      -> grayscale
+          - (H, W, 3) uint8   -> RGB
+        """
+        if img.dtype != np.uint8:
+            raise TypeError("Image must be uint8")
+
+        img = np.ascontiguousarray(img)
+        self._img_ref = img  # keep a reference alive
+
+        if img.ndim == 2:
+            h, w = img.shape
+            header = f"P5\n{w} {h}\n255\n".encode()
+        elif img.ndim == 3 and img.shape[2] == 3:
+            h, w, _ = img.shape
+            header = f"P6\n{w} {h}\n255\n".encode()
+        else:
+            raise ValueError("Image must be (H,W) or (H,W,3)")
+
+        # Build a raw PGM/PPM blob in memory - Tk's built-in photo image
+        # reader parses this directly in C, so no PIL/Pillow dependency
+        # and no per-pixel Python loop.
+        data = header + img.tobytes()
+        photo = tk.PhotoImage(data=data)
+
+        self._photo_ref = photo
+        self.label.configure(image=photo)
+
+        self.root.update()
+
+    def close(self):
+        self.root.destroy()
+
+

{structured_optics-0.4 → structured_optics-0.4.1}/structured_optics/struct_opt.py

@@ -1,10 +1,8 @@
-
-
 import numpy as np
-from scipy import fft, ndimage
+import copy
+from scipy import fft
 from contextlib import contextmanager
 from structured_optics.prop_methods import *
-import copy
 from structured_optics.utils import *
 from structured_optics.modes import *
 from structured_optics.algebra_utils import *
@@ -13,6 +11,7 @@ from structured_optics.polarization import *
 
 
 
+
 class Beam():
     """
     Represents a monochromatic paraxial optical beam on a discretized transverse grid.
@@ -908,25 +907,73 @@ class Beam():
             return p[0]
         return p
     
-    def center_mass(self, pol_index=None) -> tuple:
+
+    def center_mass(self, pol_index=None) -> tuple: 
+        """ 
+        Compute the intensity-weighted center of mass of the field in physical x and y coordinates. 
+        
+        Parameters 
+        ---------- 
+        pol_index : int, optional 
+            Polarization component to use; None uses total intensity. 
+            
+        Returns 
+        ------- 
+        tuple (x_cm, y_cm) 
+            center-of-mass coordinates in physical units. """ 
+        I = self.int_profile(pol_index) 
+
+        x = np.asarray(self.x) 
+        y = np.asarray(self.y) 
+        if x.ndim == 2: 
+            x = x[0, :] if x.shape[0] == 1 else x[0, :] 
+        if y.ndim == 2: 
+            y = y[:, 0] if y.shape[1] == 1 else y[:, 0] 
+        # Total intensity 
+        norm = np.sum(I) 
+
+        if norm == 0: 
+            raise ValueError("Cannot calculate center of mass of zero intensity.") 
+
+        # Intensity marginalized along each direction 
+        Ix = np.sum(I, axis=0) 
+        Iy = np.sum(I, axis=1) 
+
+        # Physical center of mass 
+        x_cm = np.sum(x * Ix) / norm 
+        y_cm = np.sum(y * Iy) / norm 
+
+        return x_cm, y_cm
+  
+    def std(self, pol_index=None): 
         """
-        Compute the intensity-weighted center of mass of the field, in grid
-        index coordinates.
+        Calculate the intensity-weighted spatial standard deviation
+        along x and y.
 
-        Parameters
-        ----------
-        pol_index : int, optional
-            Polarization component to use; None uses total intensity.
+        Parameters 
+        ---------- 
+        pol_index : int, optional 
+            Polarization component to use; None uses total intensity. 
 
         Returns
         -------
-        tuple
-            (row, col) center-of-mass indices, as returned by
-            `scipy.ndimage.center_of_mass`.
-        """
-        return ndimage.center_of_mass(self.int_profile(pol_index))
-  
-    def std(self, pol_index=None) -> float:
+        sigma_x, sigma_y : float
+            Intensity-weighted spatial standard deviations.
+        """
+        I = self.int_profile(pol_index) 
+        x = np.asarray(self.x) 
+        y = np.asarray(self.y) 
+        x = x[0, :] if x.ndim == 2 else x 
+        y = y[:, 0] if y.ndim == 2 else y 
+        norm = np.sum(I) 
+        Ix = np.sum(I, axis=0) 
+        Iy = np.sum(I, axis=1) 
+        x_cm, y_cm = self.center_mass(pol_index) 
+        var_x = np.sum(Ix * (x - x_cm)**2) / norm 
+        var_y = np.sum(Iy * (y - y_cm)**2) / norm 
+        return np.sqrt(var_x), np.sqrt(var_y)
+        
+    def radial_std(self, pol_index=None) -> float:
         """
         Calculate the intensity-weighted radial standard deviation of the field
         about its center of mass.
@@ -941,12 +988,9 @@ class Beam():
         float
             Intensity-weighted radial standard deviation.
         """
-        I = self.int_profile(pol_index)
-        c = self.center_mass(pol_index)
-        x0 = self.x[0, int(round(c[1]))]
-        y0 = self.y[int(round(c[0])), 0]
-        r2 = (self.x - x0)**2 + (self.y - y0)**2
-        return np.sqrt(np.average(r2, weights=I))
+        sx, sy = self.std(pol_index)
+
+        return np.sqrt(sx**2 + sy**2)
     
     def section(self, ang_min:float, ang_max:float, pol_index:int=0) -> np.ndarray:
         """
@@ -1040,6 +1084,29 @@ class Beam():
             A new, spatially cropped Beam.
         """
         return get_crop(self, center, std, window)
+
+    def apply_zernike(self, n: int, m: int, strength: float = 1) -> object:
+        """ 
+        Apply a zernike polynomial of indexes n,m where (n-m)%2 == 0  and m <=n. Action normalized by waist.
+        Used to perform aberration correction.
+
+        Parameters
+        ----------
+        n : int
+            Zernike Polynomial radial degree.
+        m : int
+            Zernike Polynomial azimuthal degree.
+        strength: float, optional
+            Intensity of the aberration correction normalized by waist. Default equals one waist.
+        
+        Returns
+        -------
+        Beam
+            self, with zernike polynomial applyed to field phase.
+
+        """
+        self.field = apply_zernike(self.x, self.y, self.waist, self.field, n, m, strenght= strength)
+        return self
     
 
     

{structured_optics-0.4 → structured_optics-0.4.1}/structured_optics/utils.py

@@ -3,6 +3,7 @@ from scipy import ndimage
 from scipy.special import hermite, genlaguerre, jv, j0, j1, kv, jn_zeros
 from scipy.optimize import brentq
 from functools import wraps
+import math
 
 
 
@@ -471,3 +472,29 @@ def inv_J1(A, a=None, n=10000):
     return np.interp(a * A, y, x)
 
 
+
+#utils for aberration correction
+
+def radial_poly(n, m, r):
+    s = 0
+    if (n - m) % 2 == 0 and m <= n:
+        for k in range((n - m) // 2 + 1):
+            s += (-1)**k * math.factorial(n-k) / (math.factorial(k) * math.factorial((n + m) // 2 - k) 
+                                                     * math.factorial((n + m) // 2 - k))* r**(n - 2*k)
+    elif (n - m) % 2 == 1 and m <= n:
+        raise ValueError("Warning: (n - m) is odd, Zernike Polynomial is zero.")
+    else:
+        raise ValueError("Invalid n and m values for Zernike polynomials.")
+    return s 
+
+def zernike(n, m, r, phi):
+    if m >= 0:
+        return radial_poly(n, m, r) * np.cos(m*phi)
+    else:
+        return radial_poly(n, -m, r) * np.sin(-m*phi)
+    
+def apply_zernike(x, y, waist, desired, n, m, strength):
+    r = np.sqrt(x**2 + y**2)/waist
+    phi = np.arctan2(y, x)
+    phase = strength * zernike(n, m, r, phi)
+    return  desired*np.exp(1j*phase)

{structured_optics-0.4 → structured_optics-0.4.1}/structured_optics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.4
+Version: 0.4.1
 Summary: Package for Structured Light simulation
 Author: Altilano C. Barbosa
 License-Expression: BSD-3-Clause
@@ -9,7 +9,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
-Requires-Dist: PyQt6
+Requires-Dist: screeninfo
 Dynamic: license-file
 
 # structured-optics
@@ -75,7 +75,7 @@ Soon...
 - Python 3.9+
 - numpy
 - scipy
-- PyQt6
+- screeninfo
 
 
 

{structured_optics-0.4 → structured_optics-0.4.1}/structured_optics.egg-info/requires.txt

@@ -1,3 +1,3 @@
 numpy
 scipy
-PyQt6
+screeninfo

structured_optics-0.4/structured_optics/slmdisplay.py

@@ -1,85 +0,0 @@
-import sys
-import numpy as np
-from PyQt6.QtWidgets import QApplication, QLabel
-from PyQt6.QtGui import QImage, QPixmap
-from PyQt6.QtCore import Qt
-
-class My_SLM(QLabel):
-    def __init__(self, screen_index=0):
-        self.app = QApplication.instance() or QApplication(sys.argv)
-        super().__init__()
-
-        screens = self.app.screens()
-        if screen_index >= len(screens):
-            raise ValueError("Invalid screen index")
-
-        screen = screens[screen_index]
-
-        # Force native window creation (CRITICAL on Linux)
-        self.setAttribute(Qt.WidgetAttribute.WA_NativeWindow)
-
-        self.setWindowFlags(
-            Qt.WindowType.FramelessWindowHint
-        )
-
-        self.show()  # must come before windowHandle()
-
-        self.windowHandle().setScreen(screen)
-        geo = screen.geometry()
-
-        # Store logical screen size
-        self.width = geo.width()
-        self.height = geo.height()
-        self.setGeometry(geo)
-
-        self.showFullScreen()
-
-        self._img_ref = None
-
-
-    def update_image(self, img: np.ndarray):
-        """
-        img:
-          - (H, W) uint8 → grayscale
-          - (H, W, 3) uint8 → RGB
-        """
-        if img.dtype != np.uint8:
-            raise TypeError("Image must be uint8")
-
-        self._img_ref = img  # keep reference alive
-
-        if img.ndim == 2:
-            h, w = img.shape
-            stride = img.strides[0]
-
-            qimg = QImage(
-                img.data,
-                w,
-                h,
-                stride,
-                QImage.Format.Format_Grayscale8
-            )
-
-        elif img.ndim == 3 and img.shape[2] == 3:
-            h, w, _ = img.shape
-            stride = img.strides[0]
-
-            qimg = QImage(
-                img.data,
-                w,
-                h,
-                stride,
-                QImage.Format.Format_RGB888
-            )
-        else:
-            raise ValueError("Image must be (H,W) or (H,W,3)")
-
-        self.setPixmap(QPixmap.fromImage(qimg))
-        self.app.processEvents()
-
-    def close(self):
-        if not self.isVisible():
-            return
-        self.hide()
-        self.setParent(None)   # detach from Qt ownership
-        self.deleteLater()