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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.4
+Version: 0.5
 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.5}/README.md

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structured_optics"
-version = "0.4"
+version = "0.5"
 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.5/structured_optics/bluestein.py

@@ -0,0 +1,118 @@
+import numpy as np
+
+
+def fft_bluestein(f, dx, dk, D_out=None, x0=0.0, k0=0.0, inverse=False):
+    """
+    Generalized 1D Fourier transform using Bluestein's algorithm.
+
+    Forward:
+        F(k) = ∫ f(x) exp(-i k x) dx
+
+    Inverse:
+        f(x) = 1/(2π) ∫ F(k) exp(+i k x) dk
+    """
+
+    f = np.asarray(f)
+    D = f.shape[-1]
+
+    if D_out is None:
+        D_out = D
+    if D < 1:
+        raise ValueError("Input cannot be empty.")
+    if D_out < 1:
+        raise ValueError("D_out must be positive.")
+    if dx <= 0:
+        raise ValueError("dx must be positive.")
+    if dk == 0:
+        raise ValueError("dk cannot be zero.")
+
+    n = np.arange(D)
+    m = np.arange(D_out)
+    a = dx * dk
+
+    # FORWARD
+    if not inverse:
+        # Chirps
+        chirp_n = np.exp(-0.5j * a * n**2)
+        chirp_m = np.exp(-0.5j * a * m**2)
+
+        # Coordinate-origin phases
+        input_phase = np.exp(-1j * k0 * dx * n)
+        output_phase = np.exp(-1j * x0 * dk * m)
+        global_phase = np.exp(-1j * k0 * x0)
+
+        # Input chirp
+        a_input = (f * input_phase * chirp_n)
+
+        # Convolution kernel
+        q = np.arange(-(D - 1),D_out)
+        kernel = np.exp(+0.5j * a * q**2)
+
+        # Linear convolution length
+        L = D + D_out - 1
+
+        # FFT padding
+        P = 1 << (L - 1).bit_length()
+
+        A = np.fft.fft(a_input, P, axis=-1)
+        B = np.fft.fft(kernel, P)
+        B = B.reshape((1,) * (f.ndim - 1) + (P,))
+        convolution = np.fft.ifft(A * B, axis=-1)
+
+        # Extract m = 0,...,D_out-1
+        convolution = np.take(convolution, np.arange(D - 1, D - 1 + D_out), axis=-1)
+
+        # Final result
+        F = (dx * global_phase * output_phase * chirp_m * convolution)
+        k = k0 + m * dk
+
+        return F, k
+
+
+    # INVERSE
+    else:
+        # Positive exponential
+        chirp_n = np.exp(+0.5j * a * n**2)
+        chirp_m = np.exp(+0.5j * a * m**2)
+        input_phase = np.exp(+1j * x0 * dk * n)
+        output_phase = np.exp(+1j * k0 * dx * m)
+        global_phase = np.exp(+1j * k0 * x0)
+        a_input = (f * input_phase * chirp_n)
+
+        # Correct convolution kernel
+        q = np.arange(-(D - 1), D_out)
+        kernel = np.exp(-0.5j * a * q**2)
+        L = D + D_out - 1
+        P = 1 << (L - 1).bit_length()
+        A = np.fft.fft(a_input, P, axis=-1)
+        B = np.fft.fft(kernel, P)
+        B = B.reshape((1,) * (f.ndim - 1) + (P,))
+        convolution = np.fft.ifft(A * B, axis=-1)
+        convolution = np.take(convolution, np.arange(D - 1, D - 1 + D_out), axis=-1)
+        result = (dk/(2*np.pi) * global_phase * output_phase * chirp_m * convolution)
+        x = x0 + m * dx
+        return result, x
+
+def fft2_bluestein(field, dx, dy, dkx, dky, Dx_out=None, Dy_out=None, x0=0.0, y0=0.0, kx0=0.0, ky0=0.0):
+    """
+        Generalized 2D Fourier transform using Bluestein's algorithm. Performs fft_bluestein twice.
+    """
+    field = np.asarray(field)
+    if field.ndim != 2:
+        raise ValueError("bluestein_fft2 expects a 2D array.")
+
+    Dy, Dx = field.shape
+    if Dx_out is None:
+        Dx_out = Dx
+    if Dy_out is None:
+        Dy_out = Dy
+
+    # x transform
+    F, kx = fft_bluestein(field, dx=dx, dk=dkx, D_out=Dx_out, x0=x0, k0=kx0)
+
+    # y transform
+    F = np.swapaxes(F, -1, -2)
+    F, ky = fft_bluestein(F, dx=dy, dk=dky, D_out=Dy_out, x0=y0, k0=ky0)
+    F = np.swapaxes(F, -1, -2)
+    return F, kx, ky
+

structured_optics-0.5/structured_optics/prop_methods.py

@@ -0,0 +1,421 @@
+import numpy as np
+from scipy import fft
+from structured_optics.bluestein import *
+
+
+def propagate_fresnel_conv(Beam, z):                                     
+    #Propagate the field by a distance z using fresnel integral. convolution method
+    k = Beam.k()
+    prop = np.exp(-1j * z * (Beam.kx ** 2 + Beam.ky ** 2) / (2 * k) + 1j*k*z)
+    Beam.fourier_field = fft.fft2(Beam.field, axes=(-2,-1))
+    Beam.field = fft.ifft2(prop*Beam.fourier_field, axes=(-2,-1))
+    return Beam
+
+def propagate_fresnel_fft(Beam, z):
+    """
+    Propagate a complex scalar field with the Fresnel approximation using
+    a single Fourier transform.
+ 
+    Parameters
+    ----------
+    Beam : object
+        Beam class containing all physical information of your beam.
+    z : float
+        Propagation distance.
+ 
+    Returns
+    -------
+    Beam : object
+        Beam class containing all physical information of your beam, with updated field and x,y meshgrid.
+    """
+    if z == 0:
+        return Beam
+
+    Dy, Dx = Beam.field.shape[-2:]
+    dx = 2*Beam.nix/Beam.Dx
+    dy = 2*Beam.niy/Beam.Dy
+    k = Beam.k()
+ 
+    # Output grid, fixed by the physics (fx = x_out / (lambda*z)) 
+    dx_out = Beam.lamb * z / (Dx * dx)
+    dy_out = Beam.lamb * z / (Dy * dy)
+    x_out = (np.arange(Dx) - Dx // 2) * dx_out
+    y_out = (np.arange(Dy) - Dy // 2) * dy_out
+    X_out, Y_out = np.meshgrid(x_out, y_out)
+ 
+    # Input quadratic phase 
+    Q1 = np.exp(1j * k / (2 * z) * (Beam.x**2 + Beam.y**2))
+ 
+    # Single FFT (fftshift/ifftshift keep x=0 <-> zero frequency) 
+    U1 = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(Beam.field * Q1, axes=(-2, -1)), axes=(-2, -1)), axes=(-2, -1)) * dx * dy
+ 
+    # Output prefactor and quadratic phase 
+    Q2 = (np.exp(1j * k * z) / (1j * Beam.lamb * z)) * \
+         np.exp(1j * k / (2 * z) * (X_out**2 + Y_out**2))
+    field_z = Q2 * U1
+
+    if dx_out < 0:
+        x_out = x_out[::-1]
+        field_z = field_z[..., :, ::-1]
+    if dy_out < 0:
+        y_out = y_out[::-1]
+        field_z = field_z[..., ::-1, :]
+
+    Beam.field = field_z
+    Beam.x, Beam.y = np.meshgrid(x_out, y_out, sparse=True)
+ 
+    return Beam
+
+def propagate_bluestein(Beam, z, x_out_range, y_out_range, Dx_out=None, Dy_out=None):
+    """
+    Single-FFT Fresnel propagation with an arbitrary, independently
+    chosen output grid, using the Bluestein (chirp-z) transform.
+ 
+    Parameters
+    ----------
+    Beam : object
+        Beam class containing all physical information of your beam.
+    z : float
+        Propagation distance. Must be nonzero; negative z back-propagates.
+    x_out_range, y_out_range : (float, float)
+        (min, max) of the desired OUTPUT region, in the same units as x, y.
+    Dx_out, Dy_out : int
+        Number of output samples along x and y. Independent of the input
+        sample count, spacing, or of lambda*z/(N*dx) -- choose whatever
+        resolution/region you need.
+ 
+    Returns
+    -------
+    Beam : object
+        Beam class containing all physical information of your beam, with updated field and x,y meshgrid.
+    """
+    if z == 0:
+        raise ValueError("Bluestein propagation requires z != 0.")
+    if Dx_out < 2 or Dy_out < 2:
+        raise ValueError("Dx_out and Dy_out must each be >= 2.")
+ 
+    x = np.asarray(Beam.x).ravel()
+    y = np.asarray(Beam.y).ravel()
+ 
+    dx_in = 2*Beam.nix/Beam.Dx
+    dy_in = 2*Beam.niy/Beam.Dy
+    x0_in = x[0]
+    y0_in = y[0]
+ 
+    x_out = np.linspace(x_out_range[0], x_out_range[1], Dx_out)
+    y_out = np.linspace(y_out_range[0], y_out_range[1], Dy_out)
+    dx_out = x_out[1] - x_out[0]
+    dy_out = y_out[1] - y_out[0]
+    x0_out = x_out[0]
+    y0_out = y_out[0]
+ 
+
+    k = Beam.k()
+    X, Y = np.meshgrid(x, y)                   # input grid, (Dy, Dx)
+    X_out, Y_out = np.meshgrid(x_out, y_out)   # output grid, (Dy_out, Dx_out)
+ 
+    # --- Input quadratic phase ---
+    Q1 = np.exp(1j * k / (2 * z) * (X**2 + Y**2))
+    g = Beam.field * Q1   # shape (..., Dy, Dx)
+ 
+    # --- Map desired output coordinates to CZT frequency-grid parameters ---
+    # cross term: exp[-i (k/z) x_out * x0]  ->  K = (k/z) * x_out
+    dKx = (k / z) * dx_out
+    Kx0 = (k / z) * x0_out
+    dKy = (k / z) * dy_out
+    Ky0 = (k / z) * y0_out
+ 
+    # --- CZT along x (last axis) ---
+    Gx, _ = fft_bluestein(g, dx=dx_in, dk=dKx, D_out=Dx_out,
+                           x0=x0_in, k0=Kx0, inverse=False)
+ 
+    # --- CZT along y (swap so y is the last axis, then swap back) ---
+    Gx = np.swapaxes(Gx, -1, -2)
+    Gxy, _ = fft_bluestein(Gx, dx=dy_in, dk=dKy, D_out=Dy_out,
+                            x0=y0_in, k0=Ky0, inverse=False)
+    Gxy = np.swapaxes(Gxy, -1, -2)   # back to (..., Dy_out, Dx_out)
+ 
+    # --- Output prefactor and quadratic phase ---
+    Q2 = (np.exp(1j * k * z) / (1j * Beam.lamb * z)) * \
+         np.exp(1j * k / (2 * z) * (X_out**2 + Y_out**2))
+ 
+    Beam.field = Q2 * Gxy
+    Beam.x, Beam.y = np.meshgrid(x_out, y_out, sparse=True)
+    Beam.Dx = Dx_out
+    Beam.Dy = Dy_out
+    Beam.nix = (x_out_range[1] - x_out_range[0])/2
+    Beam.niy = (y_out_range[1] - y_out_range[0])/2
+    Beam.kx, Beam.ky = np.meshgrid(2*np.pi*fft.fftfreq(Beam.Dx, 2*Beam.nix/(Beam.Dx-1)), 2*np.pi*fft.fftfreq(Beam.Dy, 2*Beam.niy/(Beam.Dy-1)), sparse=True)
+ 
+    return Beam
+
+
+
+def propagate_angular_spectrum(Beam, z, evanescent=False):
+    #Propagate the field by a distance z using Angular Spectrum method.
+    k = Beam.k()
+    kz2 = k**2 - Beam.kx**2 - Beam.ky**2
+    kz = np.sqrt(kz2.astype(complex))
+    if not evanescent:
+        not_evanescent = kz2 >= 0
+        kz = kz*not_evanescent
+    prop = np.exp(1j*kz*z + 1j*k*z)
+    Beam.fourier_field = fft.fft2(Beam.field, axes=(-2,-1))
+    Beam.field = fft.ifft2(prop*Beam.fourier_field, axes=(-2,-1))
+    return Beam
+
+
+def propagate_incoherent(Beam, z):
+    #Propagates the INTENSITY by a distance z using incoherent propagation. Loses phase information.
+    #without pupil function doesn't seems to work
+    k = Beam.k()
+    if z != 0:
+        h2 = np.ones_like(Beam.field)/(Beam.lamb*z)**2
+    else:
+        h2 = np.ones_like(Beam.field)
+    h2_fourier = fft.fft2(h2)
+    I_fourier = fft.fft2(Beam.int_profile())
+    Beam.field = np.sqrt(fft.ifft2(h2_fourier*I_fourier))
+    return Beam
+    
+    
+def propagate_fraunhofer(Beam, z):
+    #Propagate the field by a distance z using fraunhofer integral. Changes XY grid.
+
+    if z < 2/Beam.lamb*Beam.waist**2:
+        print("z small. Fraunhofer is probably not a good aproximation.") 
+    if z != 0:
+        k = Beam.k()
+        dx = Beam.x[0,1] - Beam.x[0,0]
+        dy = Beam.y[1,0] - Beam.y[0,0]
+        fx = np.fft.fftshift(np.fft.fftfreq(Beam.Dx, d=dx))
+        fy = np.fft.fftshift(np.fft.fftfreq(Beam.Dy, d=dy))
+        FX, FY = np.meshgrid(fx, fy, indexing="xy")
+        Beam.x = Beam.lamb * z * FX
+        Beam.y = Beam.lamb * z * FY
+        Beam.nix = np.max(Beam.x)
+        Beam.niy = np.max(Beam.y)
+        C = np.exp(1j*k*z)/(1j*Beam.lamb*z)*np.exp(1j*k*(Beam.x**2 + Beam.y**2)/(2*z))
+        Beam.fourier_field = fft.fft2(Beam.field, axes=(-2,-1))
+        Beam.field = C*fft.fftshift(Beam.fourier_field)*dx*dy
+    return Beam
+
+
+
+
+
+
+
+def suggest_propagation_method(Beam, z, aperture_sigma_factor=3.0,
+                                fraunhofer_threshold=0.1):
+    """
+    Recommend a propagation method for Beam.propagate(z, method=...).
+ 
+    Parameters
+    ----------
+    Beam : object
+        Beam instance.
+    z : float
+        Intended propagation distance.
+    aperture_sigma_factor : float, optional
+        With sigma as the spatial standart deviation, the effective aperture half-width
+        used for the Fraunhofer/paraxial checks is
+        aperture_sigma_factor * sigma (default 3.0, i.e. ~99.7% of the
+        energy for a Gaussian profile). Only affects the far-field/paraxial
+        checks -- the transfer-function sampling check (z_crit) always
+        uses the full grid, since that's a property of the numerical grid,
+        not of the beam itself.
+    fraunhofer_threshold : float, optional
+        Fresnel number below which Fraunhofer is considered valid
+        (default 0.1, i.e. within a few percent of the true far field).
+    verbose : bool, optional
+        If True, print the diagnostic numbers behind the recommendation.
+ 
+    Returns
+    -------
+    method : str
+        One of: 'none', 'AS', 'fres_c', 'fraun'.
+    info : dict
+        The underlying numbers (z_crit, fresnel_number, z_paraxial_min,
+        aperture size used, and where that size came from) in case you
+        want to make the decision yourself.
+    """
+    if z == 0:
+        print("z = 0: no propagation needed.")
+        return 'none', {}
+ 
+    abs_z = abs(z)
+    lam = Beam.lamb
+ 
+    dx = 2 * Beam.nix / Beam.Dx
+    dy = 2 * Beam.niy / Beam.Dy
+    Dx, Dy = Beam.Dx, Beam.Dy
+ 
+    # (1) transfer-function critical distance (smaller axis is the binding
+    #     one) -- always based on the grid, not the beam
+    z_crit_x = Dx * dx**2 / lam
+    z_crit_y = Dy * dy**2 / lam
+    z_crit = min(z_crit_x, z_crit_y)
+ 
+    # (2) effective aperture size for the far-field/paraxial checks:
+    #     prefer the beam's own extent (via Beam.std()) over the full
+    #     simulation window, since a beam much smaller than the window
+    #     reaches the far field far sooner than the window would suggest.
+    ax = ay = None
+    size_source = "simulation window half-width (nix, niy)"
+    if hasattr(Beam, 'std'):
+        try:
+            sigma_x, sigma_y = Beam.std()
+            if sigma_x > 0 and sigma_y > 0:
+                ax = aperture_sigma_factor * sigma_x
+                ay = aperture_sigma_factor * sigma_y
+                size_source = f"{aperture_sigma_factor}*sigma from Beam.std()"
+        except Exception:
+            pass  # fall back to window size below
+    if ax is None or ay is None:
+        ax, ay = Beam.nix, Beam.niy
+ 
+    # (3) Fraunhofer / Fresnel number
+    a2 = ax**2 + ay**2
+    fresnel_number = a2 / (lam * abs_z)
+ 
+    # (4) paraxial validity floor (Goodman's criterion), same aperture size
+    z_paraxial_min = (np.pi / (4 * lam) * a2**2) ** (1 / 3)
+ 
+    info = {
+        'z_crit': z_crit,
+        'fresnel_number': fresnel_number,
+        'z_paraxial_min': z_paraxial_min,
+        'aperture_size': (ax, ay),
+        'aperture_size_source': size_source,
+    }
+ 
+    if fresnel_number < fraunhofer_threshold:
+        method = 'fraun'
+    elif abs_z <= z_crit:
+        method = 'AS'
+    elif abs_z < z_paraxial_min:
+        # Too close for paraxial single-step Fresnel to be trustworthy,
+        # yet past z_crit for the transfer-function sampling argument --
+        # fall back to the exact angular spectrum method.
+        method = 'AS'
+    else:
+        method = 'fres_c'
+
+    print("Estimating best propagation method.")
+    print(f"z = {z:.4g} m")
+    print(f"  aperture size used ({size_source}): ax={ax:.4g} m, ay={ay:.4g} m")
+    print(f"  critical (transfer-function) distance z_crit = {z_crit:.4g} m")
+    print(f"  Fresnel number                       Nf      = {fresnel_number:.4g}")
+    print(f"  paraxial validity floor               z_min   = {z_paraxial_min:.4g} m")
+    print(f"  -> recommended method: {method}")
+ 
+    return method, info
+
+
+
+
+def estimate_bluestein_range(Beam, z, n_sigma=5.0, equal_grid=True):
+    """
+    Estimate the output window to pass to propagate_bluestein so the
+    propagated beam is fully contained without edge clipping.
+ 
+    Parameters
+    ----------
+    Beam : object
+        Beam instance.
+    z : float
+        Propagation distance you intend to use.
+    n_sigma : float, optional
+        How many standard deviations of the predicted beam width to
+        include on each side (default 5.0 -- for a Gaussian-like profile
+        this captures effectively all the energy; increase for beams
+        with heavier tails, e.g. Bessel-like profiles).
+    equal_grid : Bool, optional
+        If True x and y grid have the same output size, set to the bigger one.
+ 
+    Returns
+    -------
+    x_out_range, y_out_range : (float, float)
+        Suggested ranges for propagate_bluestein.
+    info : dict
+        Diagnostic quantities: current/predicted sigma, angular spread,
+        predicted centroid, etc.
+    """
+    field = Beam.field
+    X, Y = Beam.x, Beam.y   # sparse grids, shapes (1,Dx) and (Dy,1)
+    dx = X[0, 1] - X[0, 0]
+    dy = Y[1, 0] - Y[0, 0]
+    k = Beam.k()
+ 
+    # --- Spatial intensity moments (sum over any polarization axis) ---
+    I = np.sum(np.abs(field) ** 2, axis=0)          # shape (Dy, Dx)
+    P = np.sum(I) * dx * dy
+ 
+    xbar0 = np.sum(X * I) * dx * dy / P
+    ybar0 = np.sum(Y * I) * dx * dy / P
+    varx0 = np.sum((X - xbar0) ** 2 * I) * dx * dy / P
+    vary0 = np.sum((Y - ybar0) ** 2 * I) * dx * dy / P
+    sigma_x0 = np.sqrt(varx0)
+    sigma_y0 = np.sqrt(vary0)
+ 
+    # --- Angular-spectrum moments (beam's own Fourier content) ---
+    A = fft.fft2(field, axes=(-2, -1))
+    S = np.sum(np.abs(A) ** 2, axis=0)              # shape (Dy, Dx)
+    S_tot = np.sum(S)
+ 
+    kx_bar0 = np.sum(Beam.kx * S) / S_tot
+    ky_bar0 = np.sum(Beam.ky * S) / S_tot
+    var_kx0 = np.sum((Beam.kx - kx_bar0) ** 2 * S) / S_tot
+    var_ky0 = np.sum((Beam.ky - ky_bar0) ** 2 * S) / S_tot
+ 
+    theta_x_bar0 = kx_bar0 / k
+    theta_y_bar0 = ky_bar0 / k
+    sigma_thetax0 = np.sqrt(var_kx0) / k
+    sigma_thetay0 = np.sqrt(var_ky0) / k
+ 
+    # --- Cross term: existing wavefront curvature, via local phase gradient ---
+    cross_x0 = 0.0
+    cross_y0 = 0.0
+
+    dUdx = fft.ifft2(1j * Beam.kx * A, axes=(-2, -1))
+    dUdy = fft.ifft2(1j * Beam.ky * A, axes=(-2, -1))
+    # Im(U* dU/dx) = |U|^2 * dphi/dx  (local intensity-weighted phase slope)
+    local_px = np.sum(np.conj(field) * dUdx, axis=0).imag
+    local_py = np.sum(np.conj(field) * dUdy, axis=0).imag
+    cross_x0 = np.sum((X - xbar0) * local_px) * dx * dy / (k * P)
+    cross_y0 = np.sum((Y - ybar0) * local_py) * dx * dy / (k * P)
+    
+
+    
+    # --- Propagate moments to the target z (exact paraxial identity) ---
+    xbar_z = xbar0 + z * theta_x_bar0
+    ybar_z = ybar0 + z * theta_y_bar0
+ 
+    varx_z = varx0 + 2 * z * cross_x0 + z**2 * sigma_thetax0**2
+    vary_z = vary0 + 2 * z * cross_y0 + z**2 * sigma_thetay0**2
+    sigma_x_z = np.sqrt(max(varx_z, 0.0))
+    sigma_y_z = np.sqrt(max(vary_z, 0.0))
+ 
+    half_x = n_sigma * sigma_x_z
+    half_y = n_sigma * sigma_y_z
+
+    if equal_grid ==True:
+        hm = np.max((half_x, half_y))
+    half_x = hm
+    half_y = hm
+ 
+    x_out_range = (xbar_z - half_x, xbar_z + half_x)
+    y_out_range = (ybar_z - half_y, ybar_z + half_y)
+ 
+    info = {
+        'sigma_x0': sigma_x0, 'sigma_y0': sigma_y0,
+        'sigma_thetax0': sigma_thetax0, 'sigma_thetay0': sigma_thetay0,
+        'cross_x0': cross_x0, 'cross_y0': cross_y0,
+        'xbar0': xbar0, 'ybar0': ybar0,
+        'xbar_z': xbar_z, 'ybar_z': ybar_z,
+        'sigma_x_z': sigma_x_z, 'sigma_y_z': sigma_y_z,
+    }
+ 
+    return x_out_range, y_out_range, info
+

structured_optics-0.5/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.5}/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.
@@ -855,6 +854,16 @@ class Beam():
             Rayleigh range, zr = pi*waist**2/lamb.
         """
         return np.pi*self.waist**2/self.lamb
+
+    def k(self) -> float:
+        """
+        Compute k vector magnitude in vacum.
+        
+        Returns
+        -------
+        float
+            k vector magniture in vaccum"""
+        return 2*np.pi/self.lamb
     
     def int_profile(self, pol_index=None) -> np.ndarray:
         """
@@ -908,25 +917,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 +998,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 +1094,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, strength= strength)
+        return self
     
 
     
@@ -1384,29 +1461,54 @@ class Beam():
 
     
     #Propagation 
-    def propagate(self, z, method='fresnel', renorm=False):           
+    def propagate(self, z, method='fres_c', renorm=False, **kwargs):           
         """
         Parameters
         ----------
         z : float
             Propagation distance.
-        method : {'fresnel', 'fraunhofer', 'incoherent'}, optional
-            Diffraction model used for propagation. An unrecognized value
-            currently prints a warning and leaves the field unchanged.
+        method : {'auto', 'fresn_c', 'AS', 'fraun', 'fres_f', 'blue', 'blue_fix', 'inc'}, optional
+            Diffraction model used for propagation. Default is 'fres_c'.
         renorm : bool, optional
             If True, renormalize total power to 1 after propagation.
+        evanescent : bool, optional
+            Optional in Angular Spectrum method. Default is False, but if True the code keeps the evanscent contribution to the field.
+        x_out_range, y_out_range : tuple
+            Necessary for bluestein method without fixed window range. tuple containing (x_min, x_max), (y_min, y_max) of the output window.
+        Dx_out, Dy_out : int, optional
+            Optional for bluestein method. Sets number of output samples along x and y.
+        n_sigma : float, optional
+            Optional in Bluestein Fix. How many standard deviations the bluestein_fix window range should be.
+        
 
         Returns
         -------
         Beam
             self, with field propagated by distance z (and renormalized if requested).
         """
-        if method == 'fresnel':
-            self = propagate_fresnel(self, z)
-        elif method == 'fraunhofer':
+        if method == 'auto':
+            method, _ = suggest_propagation_method(self, z)
+            if method == 'none':
+                return self
+
+        if method == 'fres_c':
+            self = propagate_fresnel_conv(self, z)
+        elif method == 'AS':
+            self = propagate_angular_spectrum(self, z, **kwargs)
+        elif method == 'fraun':
             self = propagate_fraunhofer(self, z)
-        elif method == 'incoherent':
+
+        elif method == 'fres_f':
+            self = propagate_fresnel_fft(self, z)
+        elif method == 'blue':
+            self = propagate_bluestein(self, z, **kwargs)
+        elif method == 'blue_fix':
+            x_out_range, y_out_range, _ = estimate_bluestein_range(self, z, **kwargs)
+            self = propagate_bluestein(self, z, x_out_range = x_out_range, y_out_range = y_out_range, Dx_out = self.Dx, Dy_out = self.Dy)
+
+        elif method == 'inc':
             self = propagate_incoherent(self, z)
+
         else:
             raise Exception('Unable to propagate, insert valid method.') 
         if renorm == True:

{structured_optics-0.4 → structured_optics-0.5}/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.5}/structured_optics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.4
+Version: 0.5
 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.5}/structured_optics.egg-info/SOURCES.txt

@@ -1,9 +1,9 @@
 LICENSE
 README.md
 pyproject.toml
-setup.py
 structured_optics/__init__.py
 structured_optics/algebra_utils.py
+structured_optics/bluestein.py
 structured_optics/hologram.py
 structured_optics/modes.py
 structured_optics/polarization.py

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

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

structured_optics-0.4/setup.py

@@ -1,8 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='structured_optics',
-    version='0.3',
-    packages=find_packages()
-
-)

structured_optics-0.4/structured_optics/prop_methods.py

@@ -1,46 +0,0 @@
-import numpy as np
-from scipy import fft
-
-
-def propagate_fresnel(Beam, z):                                     
-    #Propagate the field by a distance z using fresnel integral. convolution method
-    k = 2*np.pi/Beam.lamb
-    prop = np.exp(-1j * z * (Beam.kx ** 2 + Beam.ky ** 2) / (2 * k) + 1j*k*z)
-    Beam.fourier_field = fft.fft2(Beam.field, axes=(-2,-1))
-    Beam.field = fft.ifft2(prop*Beam.fourier_field, axes=(-2,-1))
-    return Beam
-
-def propagate_incoherent(Beam, z):
-    #Propagates the INTENSITY by a distance z using incoherent propagation. Loses phase information.
-    #without pupil function doesn't seems to work
-    k = 2*np.pi/Beam.lamb
-    if z != 0:
-        h2 = np.ones_like(Beam.field)/(Beam.lamb*z)**2
-    else:
-        h2 = np.ones_like(Beam.field)
-    h2_fourier = fft.fft2(h2)
-    I_fourier = fft.fft2(Beam.int_profile())
-    Beam.field = np.sqrt(fft.ifft2(h2_fourier*I_fourier))
-    return Beam
-    
-    
-def propagate_fraunhofer(Beam, z):
-    #Propagate the field by a distance z using fraunhofer integral. Changes XY grid.
-
-    if z < 2/Beam.lamb*Beam.waist**2:
-        print("z small. Fraunhofer is probably not a good aproximation.") 
-    if z != 0:
-        k = 2*np.pi/Beam.lamb
-        dx = Beam.x[0,1] - Beam.x[0,0]
-        dy = Beam.y[1,0] - Beam.y[0,0]
-        fx = np.fft.fftshift(np.fft.fftfreq(Beam.Dx, d=dx))
-        fy = np.fft.fftshift(np.fft.fftfreq(Beam.Dy, d=dy))
-        FX, FY = np.meshgrid(fx, fy, indexing="xy")
-        Beam.x = Beam.lamb * z * FX
-        Beam.y = Beam.lamb * z * FY
-        Beam.nix = np.max(Beam.x)
-        Beam.niy = np.max(Beam.y)
-        C = np.exp(1j*k*z)/(1j*Beam.lamb*z)*np.exp(1j*k*(Beam.x**2 + Beam.y**2)/(2*z))
-        Beam.fourier_field = fft.fft2(Beam.field, axes=(-2,-1))
-        Beam.field = C*fft.fftshift(Beam.fourier_field)*dx*dy
-    return Beam

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()