structured-optics 0.6__tar.gz → 0.6.2__tar.gz

{structured_optics-0.6/structured_optics.egg-info → structured_optics-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.6
+Version: 0.6.2
 Summary: Package for Structured Light simulation
 Author: Altilano C. Barbosa
 License-Expression: BSD-3-Clause
@@ -59,18 +59,22 @@ beam.propagate(z=0.1, method='fres_c')
 # Look at the intensity profile
 import matplotlib.pyplot as plt
 plt.pcolormesh(beam.x, beam.y, beam.int_profile())
+plt.colorbar()
 plt.show()
 ```
 
 Expected output:
-([examples/image_examples/LG_20 prop.png](https://github.com/Altilano/structured-optics/blob/main/examples/image_examples/LG_20%20prop.png))
+<p align="center">
+  <img src="https://github.com/Altilano/structured-optics/blob/main/examples/image_examples/LG_20%20prop.png" width="400" alt="LG20">
+</p>
+
 
 ## Documentation
 
 Full API documentation, including all mode types, propagation methods, and
 optical elements, is available at:
 
-Soon...
+(https://altilano.github.io/structured-optics/)
 
 ## Requirements
 
@@ -96,7 +100,7 @@ This project is licensed under the BSD-3-Clause License. See `LICENSE` for detai
 
  - Documentation.
  - Benchmark and optimization.
- - Support for high NA focalization. (Non paraxial propagation)
+ - Support for high NA focalization. (Non paraxial propagation, no scalar field)
  - Cuda and ROCm speed up.
  - Support for propagation inside linear medium.
 

{structured_optics-0.6 → structured_optics-0.6.2}/README.md

@@ -45,18 +45,22 @@ beam.propagate(z=0.1, method='fres_c')
 # Look at the intensity profile
 import matplotlib.pyplot as plt
 plt.pcolormesh(beam.x, beam.y, beam.int_profile())
+plt.colorbar()
 plt.show()
 ```
 
 Expected output:
-([examples/image_examples/LG_20 prop.png](https://github.com/Altilano/structured-optics/blob/main/examples/image_examples/LG_20%20prop.png))
+<p align="center">
+  <img src="https://github.com/Altilano/structured-optics/blob/main/examples/image_examples/LG_20%20prop.png" width="400" alt="LG20">
+</p>
+
 
 ## Documentation
 
 Full API documentation, including all mode types, propagation methods, and
 optical elements, is available at:
 
-Soon...
+(https://altilano.github.io/structured-optics/)
 
 ## Requirements
 
@@ -82,7 +86,7 @@ This project is licensed under the BSD-3-Clause License. See `LICENSE` for detai
 
  - Documentation.
  - Benchmark and optimization.
- - Support for high NA focalization. (Non paraxial propagation)
+ - Support for high NA focalization. (Non paraxial propagation, no scalar field)
  - Cuda and ROCm speed up.
  - Support for propagation inside linear medium.
 

{structured_optics-0.6 → structured_optics-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structured_optics"
-version = "0.6"
+version = "0.6.2"
 description = "Package for Structured Light simulation"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -18,3 +18,6 @@ dependencies = [
     "scipy",
     "screeninfo"
 ]
+
+[tool.setuptools]
+packages = ["structured_optics"]

{structured_optics-0.6 → structured_optics-0.6.2}/structured_optics/__init__.py

@@ -2,4 +2,4 @@ from .struct_opt import *
 from .modes import *
 from .masks import *
 from .polarization import *
-from .utils import overlap, int_overlap
+from .tools import *

structured_optics-0.6.2/structured_optics/bluestein.py

@@ -0,0 +1,229 @@
+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
+    (chirp-z transform).
+ 
+    Unlike a standard FFT, this evaluates the continuous Fourier
+    integral on arbitrary, independently chosen input/output sample
+    spacings (`dx`, `dk`) and offsets (`x0`, `k0`), and can change the
+    number of samples from `D` (input) to `D_out` (output). It works by
+    rewriting the transform as a linear convolution (via the standard
+    Bluestein/chirp-z trick) and evaluating that convolution with zero-
+    padded FFTs, so it costs O((D + D_out) log(D + D_out)) rather than
+    the O(D * D_out) of a direct sum.
+ 
+    Forward:
+        F(k) = integral of f(x) * exp(-i k x) dx
+ 
+    Inverse:
+        f(x) = 1/(2*pi) * integral of F(k) * exp(+i k x) dk
+ 
+    Parameters
+    ----------
+    f : array_like
+        Input samples. The transform is taken along the last axis, so
+        `f` may have leading batch dimensions (shape `(..., D)`).
+    dx : float
+        Input sample spacing. Must be positive. In inverse mode, this
+        is the desired *output* spacing (of `x`).
+    dk : float
+        Output sample spacing. Must be nonzero. In inverse mode, this
+        is the *input* spacing (of `k`/`F`).
+    D_out : int, optional
+        Number of output samples. Defaults to `D` (the input length,
+        i.e. `f.shape[-1]`), giving a same-length transform.
+    x0 : float, optional
+        Origin of the `x` grid (forward: input origin; inverse: output
+        origin). Defaults to 0.0.
+    k0 : float, optional
+        Origin of the `k` grid (forward: output origin; inverse: input
+        origin). Defaults to 0.0.
+    inverse : bool, optional
+        If False (default), compute the forward transform
+        `f(x) -> F(k)`. If True, compute the inverse transform
+        `F(k) -> f(x)` (with `f` here holding the input spectrum
+        samples).
+ 
+    Returns
+    -------
+    result : np.ndarray
+        Forward mode: the transformed array `F`, of shape
+        `(..., D_out)`.
+        Inverse mode: the reconstructed array `f`, of shape
+        `(..., D_out)`.
+    coords : np.ndarray
+        Forward mode: the output `k` grid, `k0 + m*dk` for
+        `m = 0, ..., D_out-1`.
+        Inverse mode: the output `x` grid, `x0 + m*dx` for
+        `m = 0, ..., D_out-1`.
+ 
+    Raises
+    ------
+    ValueError
+        If the input is empty, `D_out` is not positive, `dx` is not
+        positive, or `dk` is zero.
+
+    Reference
+    ---------
+        [1] Hu, Yanlei, et al. "Efficient full-path optical calculation of scalar and vector diffraction using the Bluestein method." 
+            Light: Science & Applications 9.1 (2020): 119.
+    """
+
+
+    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 (forward) Fourier transform using Bluestein's
+    algorithm, applied separably along each axis.
+ 
+    Performs `fft_bluestein` along the last axis (x), then along the
+    remaining axis (y), i.e. a separable 2D chirp-z transform with
+    independently chosen sample spacing, sample count, and origin for
+    each axis.
+ 
+    Parameters
+    ----------
+    field : array_like
+        2D input array of shape `(Dy, Dx)`.
+    dx : float
+        Input sample spacing along x.
+    dy : float
+        Input sample spacing along y.
+    dkx : float
+        Output sample spacing along kx. Must be nonzero.
+    dky : float
+        Output sample spacing along ky. Must be nonzero.
+    Dx_out : int, optional
+        Number of output samples along x. Defaults to `Dx`
+        (`field.shape[1]`).
+    Dy_out : int, optional
+        Number of output samples along y. Defaults to `Dy`
+        (`field.shape[0]`).
+    x0 : float, optional
+        Origin of the input x grid. Defaults to 0.0.
+    y0 : float, optional
+        Origin of the input y grid. Defaults to 0.0.
+    kx0 : float, optional
+        Origin of the output kx grid. Defaults to 0.0.
+    ky0 : float, optional
+        Origin of the output ky grid. Defaults to 0.0.
+ 
+    Returns
+    -------
+    F : np.ndarray
+        Transformed array, of shape `(Dy_out, Dx_out)`.
+    kx : np.ndarray
+        Output kx grid, `kx0 + m*dkx` for `m = 0, ..., Dx_out-1`.
+    ky : np.ndarray
+        Output ky grid, `ky0 + m*dky` for `m = 0, ..., Dy_out-1`.
+ 
+    Raises
+    ------
+    ValueError
+        If `field` is not 2-dimensional, or if any of the underlying
+        `fft_bluestein` calls raise (e.g. non-positive spacing, zero
+        `dk`).
+    """
+
+    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.6 → structured_optics-0.6.2}/structured_optics/diagnostics.py

@@ -1,5 +1,4 @@
 import numpy as np
-
 from .utils import get_section
 
 
@@ -260,21 +259,5 @@ class BeamDiagnostics:
         return self
     
 
-        """
-        Parameters
-        ----------
-        center : tuple of float, optional
-            (x, y) center of the crop window. Defaults to the beam's own centroid.
-        std : float, optional
-            Standard deviation used to size the crop window. Defaults to the
-            beam's own computed std.
-        window : float, optional
-            Multiplier on `std` defining the half-width of the crop region.
 
-        Returns
-        -------
-        Beam
-            A new, spatially cropped Beam.
-        """
-        return get_crop(self, center, std, window)
 

structured_optics-0.6.2/structured_optics/hologram.py

@@ -0,0 +1,133 @@
+import numpy as np
+from .utils import inv_J0, inv_J1, inv_sinc
+
+__all__ =["slm_hologram", "dmd_hologram"]
+
+
+
+def slm_hologram(beam, x_grating:int, y_grating:int, method:str = 'bessel1', input_beam:object= None, 
+                 eps:float = np.finfo(float).eps, max_range:int = 255)-> np.ndarray:
+    """
+    Parameters
+    ----------
+    x_grating : int
+        Carrier grating spatial frequency along x (grid pixels).
+    y_grating : int
+        Carrier grating spatial frequency along y (grid pixels).
+    method : str, optional
+        Amplitude/phase encoding scheme used to build the hologram.
+    input_beam : Beam, optional
+        Reference illumination beam; defaults to self if None.
+    eps : float, optional
+        Small value added to avoid division by zero during encoding.
+    max_range : int, optional
+        Output gray-level range (e.g. 255 for an 8-bit SLM lookup table).
+
+    Returns
+    -------
+    ndarray
+        Encoded hologram pattern, shape (Dy, Dx), ready for SLM display.
+
+    Reference
+    ---------
+        [1] T. Clark, R. Offer, S. Franke-Arnold, A. Arnold, and N. Radwell, 
+        "Comparison of beam generation techniques using a phase only spatial light modulator," 
+        Opt. Express  24, 6249-6264 (2016).
+    """
+    
+    dx = (beam.x[0,1] - beam.x[0,0])
+    dy = (beam.y[1,0] - beam.y[0,0])
+    if input_beam is None:
+        input_field = np.exp(-((beam.x**2 + beam.y**2)/(2*np.max(beam.x))**2))
+    else:
+        input_field = input_beam.Ex
+    desired = beam.Ex/np.max(np.abs(beam.Ex))
+    lamb_x = dx*x_grating
+    lamb_y = dy*y_grating
+    Ain = np.abs(input_field)
+    Ain = Ain / Ain.max()
+    Ades = np.abs(desired)
+    s = np.min(Ain / (Ades + eps))
+    Ades = s * Ades
+    A_rel = Ades / Ain
+    phi_g = np.mod(2*np.pi*(beam.x/lamb_x + beam.y/lamb_y), 2*np.pi)
+    phi_relg = np.angle(desired) - np.angle(input_field) + phi_g
+    if method == 'simple':
+        H = A_rel*phi_relg
+    elif method == 'g_holo':
+        edg = desired*np.exp(1j*phi_g)
+        N = np.min(np.abs(input_field)/(np.abs(desired) + 1e-9))
+        H = np.angle(N*edg + input_field)
+    elif method == 'davis':
+        H = (1-inv_sinc(A_rel)/np.pi)*phi_relg
+    elif method == 'bolduc':
+        M = 1+inv_sinc(A_rel)/np.pi
+        H = M*(phi_relg - np.pi*M)
+    elif method == 'bessel0':
+        H = phi_relg + inv_J0(A_rel)*np.sin(phi_relg)
+    elif method == 'bessel1':
+        H = inv_J1(A_rel)*np.sin(phi_relg)
+    else:
+        raise ValueError('Error! method must be simple, g_holo, davis, bolduc, bessel0 or bessel1.')
+    H = max_range * (H - H.min()) / (H.max() - H.min())
+    return H.astype(np.uint8)
+
+
+def dmd_hologram(beam, cx:float, cy:float, sign:int=1, input:object=None)-> np.ndarray:
+    """ 
+    Generate a binary-amplitude DMD hologram. 
+    
+    Parameters 
+    ---------- 
+    beam : Beam 
+        Desired output beam. Its Ex component defines the target amplitude and phase. 
+    cx, cy : float 
+        Carrier frequencies expressed in DMD pixel units. 
+    sign : int 
+        Controls the binary hologram orientation. Usually +1 or -1. 
+    input : Beam 
+        Optional Incident beam illuminating the DMD. If None, the incident beam is assumed 
+        to have uniform amplitude and zero phase, reproducing the original behavior. 
+    
+    Returns 
+    ------- 
+    H : ndarray 
+        Binary DMD hologram. 
+        
+    Reference
+    ---------
+        [1] Scholes, Stirling, et al. "Structured light with digital micromirror devices: a guide to best practice." 
+        Optical Engineering 59.4 (2020): 041202-041202.""" 
+    
+    # Target field 
+    target = beam.Ex 
+    # Target amplitude and phase 
+    target_amp = np.abs(target) 
+    target_phase = np.angle(target) 
+
+    if input is None: 
+        U = target_amp / np.amax(target_amp) 
+        phi = target_phase 
+    else: 
+        input_field = input.Ex 
+        input_amp = np.abs(input_field) 
+        input_phase = np.angle(input_field) 
+  
+        eps = np.finfo(float).eps 
+        U = target_amp / np.maximum(input_amp, eps) 
+        phi = target_phase - input_phase 
+        max_U = np.amax(U) 
+        if max_U > 0: 
+            U = U / max_U 
+
+    A = np.arcsin(U) 
+    fx = cx * beam.Dx / (2 * beam.nix) 
+    fy = cy * beam.Dy / (2 * beam.niy) 
+    G = fx * beam.x + fy * beam.y 
+
+    H = 0.5 + sign * 0.5 * np.sign( np.cos(phi + 2 * np.pi * G) - np.cos(A) ) 
+    return H
+
+
+
+