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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured_optics
-Version: 0.5
+Version: 0.6
 Summary: Package for Structured Light simulation
 Author: Altilano C. Barbosa
 License-Expression: BSD-3-Clause
@@ -47,15 +47,14 @@ pip install structured-optics
 ```python
 import structured_optics as so
 
-# Create a beam on a 10mm x 10mm (2*5e-3) grid with 256x256 points
-beam = so.Beam(nix=5e-3, Dx=256, waist=1e-3, lamb=1064e-9)
+# Create a beam on a 10mm x 10mm (2*5e-3) grid with 512x512 points
+beam = so.Beam(nix=5e-3, Dx=512, waist=1e-3, lamb=1064e-9)
 
 # Set the field to a Laguerre-Gaussian mode with l=2, p=0
 beam.lg(l=2, p=0)
 
-# Propagate 10 cm and check total power
-beam.propagate(z=0.1, method='fresnel')
-print(beam.Power())
+# Propagate 10 cm using Fresnel Convolution
+beam.propagate(z=0.1, method='fres_c')
 
 # Look at the intensity profile
 import matplotlib.pyplot as plt
@@ -63,6 +62,9 @@ plt.pcolormesh(beam.x, beam.y, beam.int_profile())
 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))
+
 ## Documentation
 
 Full API documentation, including all mode types, propagation methods, and
@@ -90,4 +92,13 @@ This project is licensed under the BSD-3-Clause License. See `LICENSE` for detai
 
 ## Citation
 
+## To do
+
+ - Documentation.
+ - Benchmark and optimization.
+ - Support for high NA focalization. (Non paraxial propagation)
+ - Cuda and ROCm speed up.
+ - Support for propagation inside linear medium.
+
+
 

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

@@ -1,79 +1,90 @@
-# structured-optics
-
-A Python library for generating, propagating, and analyzing structured light beams
-(Hermite-Gaussian, Laguerre-Gaussian, Bessel, Ince-Gaussian, fiber LP modes, and more)
-on a discretized transverse grid.
-
-[![PyPI version](https://img.shields.io/pypi/v/structured-optics.svg)](https://pypi.org/project/structured-optics/)
-
-[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-
-## Features
-
-- **Mode generation**: Hermite-Gaussian, Laguerre-Gaussian, Bessel, Gaussian-Bessel,
-  Ince-Gaussian (even/odd/helical), fractional OAM, fiber LP modes, and geometric
-  apertures (circle, square, triangle).
-- **Propagation**: Fresnel, Fraunhofer, and incoherent propagation methods.
-- **Polarization**: vector beams with Ex/Ey/Ez components, Jones-matrix optics
-  (waveplates, polarizers).
-- **Optical elements**: lenses (spherical, astigmatic, tilted), slits, irises,
-  and other amplitude/phase masks.
-- **Analysis**: power, intensity and phase profiles, centroid, beam size (std),
-  angular sections, and modal decomposition (HG/LG/Bessel basis projections).
-- **Holography**: SLM and DMD hologram generation for experimental beam shaping.
-
-## Installation
-
-```bash
-pip install structured-optics
-```
-
-## Quick start
-
-```python
-import structured_optics as so
-
-# Create a beam on a 10mm x 10mm (2*5e-3) grid with 256x256 points
-beam = so.Beam(nix=5e-3, Dx=256, waist=1e-3, lamb=1064e-9)
-
-# Set the field to a Laguerre-Gaussian mode with l=2, p=0
-beam.lg(l=2, p=0)
-
-# Propagate 10 cm and check total power
-beam.propagate(z=0.1, method='fresnel')
-print(beam.Power())
-
-# Look at the intensity profile
-import matplotlib.pyplot as plt
-plt.pcolormesh(beam.x, beam.y, beam.int_profile())
-plt.show()
-```
-
-## Documentation
-
-Full API documentation, including all mode types, propagation methods, and
-optical elements, is available at:
-
-Soon...
-
-## Requirements
-
-- Python 3.9+
-- numpy
-- scipy
-- screeninfo
-
-
-
-## Contributing
-
-Issues and pull requests are welcome at
-[github.com/Altilano/structured-optics](https://github.com/Altilano/structured-optics).
-
-## License
-
-This project is licensed under the BSD-3-Clause License. See `LICENSE` for details.
-
-## Citation
-
-
+# structured-optics
+
+A Python library for generating, propagating, and analyzing structured light beams
+(Hermite-Gaussian, Laguerre-Gaussian, Bessel, Ince-Gaussian, fiber LP modes, and more)
+on a discretized transverse grid.
+
+[![PyPI version](https://img.shields.io/pypi/v/structured-optics.svg)](https://pypi.org/project/structured-optics/)
+
+[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+## Features
+
+- **Mode generation**: Hermite-Gaussian, Laguerre-Gaussian, Bessel, Gaussian-Bessel,
+  Ince-Gaussian (even/odd/helical), fractional OAM, fiber LP modes, and geometric
+  apertures (circle, square, triangle).
+- **Propagation**: Fresnel, Fraunhofer, and incoherent propagation methods.
+- **Polarization**: vector beams with Ex/Ey/Ez components, Jones-matrix optics
+  (waveplates, polarizers).
+- **Optical elements**: lenses (spherical, astigmatic, tilted), slits, irises,
+  and other amplitude/phase masks.
+- **Analysis**: power, intensity and phase profiles, centroid, beam size (std),
+  angular sections, and modal decomposition (HG/LG/Bessel basis projections).
+- **Holography**: SLM and DMD hologram generation for experimental beam shaping.
+
+## Installation
+
+```bash
+pip install structured-optics
+```
+
+## Quick start
+
+```python
+import structured_optics as so
+
+# Create a beam on a 10mm x 10mm (2*5e-3) grid with 512x512 points
+beam = so.Beam(nix=5e-3, Dx=512, waist=1e-3, lamb=1064e-9)
+
+# Set the field to a Laguerre-Gaussian mode with l=2, p=0
+beam.lg(l=2, p=0)
+
+# Propagate 10 cm using Fresnel Convolution
+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.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))
+
+## Documentation
+
+Full API documentation, including all mode types, propagation methods, and
+optical elements, is available at:
+
+Soon...
+
+## Requirements
+
+- Python 3.9+
+- numpy
+- scipy
+- screeninfo
+
+
+
+## Contributing
+
+Issues and pull requests are welcome at
+[github.com/Altilano/structured-optics](https://github.com/Altilano/structured-optics).
+
+## License
+
+This project is licensed under the BSD-3-Clause License. See `LICENSE` for details.
+
+## Citation
+
+## To do
+
+ - Documentation.
+ - Benchmark and optimization.
+ - Support for high NA focalization. (Non paraxial propagation)
+ - Cuda and ROCm speed up.
+ - Support for propagation inside linear medium.
+
+
+

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structured_optics"
-version = "0.5"
+version = "0.6"
 description = "Package for Structured Light simulation"
 readme = "README.md"
 license = "BSD-3-Clause"

structured_optics-0.6/structured_optics/__init__.py

@@ -0,0 +1,5 @@
+from .struct_opt import *
+from .modes import *
+from .masks import *
+from .polarization import *
+from .utils import overlap, int_overlap

structured_optics-0.6/structured_optics/diagnostics.py

@@ -0,0 +1,280 @@
+import numpy as np
+
+from .utils import get_section
+
+
+class BeamDiagnostics:
+    """
+    Mixin providing measurement/diagnostic methods for Beam: power,
+    intensity/phase profiles, centroid and width statistics, angular
+    sections, normalization and more.
+    """
+
+    def Power(self, pol_index=None) -> float:
+        """Get the total optical Power via numerical integration of the intensity profile 
+        (trapezoidal-like Riemann sum with the grid's cell area)
+        
+        Parameters
+        ----------
+        pol_index: int, optional
+            Polarization component into which the resulting power is measured. Default is power of 
+            all field components.
+
+        Returns
+        -------
+        float
+        """
+        return np.sum(self.int_profile(pol_index))*(4*self.nix/self.Dx)*(self.niy/self.Dy)
+
+    
+    def zr(self) -> float:
+        """
+        Compute the Rayleigh range of the beam from its `waist` and `lamb`.
+
+        Returns
+        -------
+        float
+            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:
+        """
+        Get intensity profile.
+
+        pol_index=None -> total intensity
+        pol_index=0    -> Ex intensity
+        pol_index=1    -> Ey intensity
+        pol_index=2    -> Ez intensity
+
+        Parameters
+        ----------
+        pol_index: int, optional
+            Polarization component into which the resulting intensity profile is measured. Default is sum of 
+            all intensity components.
+
+        Return
+        ------
+        ndarray
+            Array with intensity profile (x,y).
+        """
+        if pol_index is None:
+            return np.sum(np.abs(self.field)**2, axis=0)
+        return np.abs(self.field[pol_index])**2
+
+    
+    def phase(self, pol_index=None, twopi=False) -> np.ndarray:
+        """
+        Parameters
+        ----------
+        pol_index : int or None, optional
+            None returns phase of all components; 0/1/2 returns the phase of
+            Ex/Ey/Ez respectively.
+        twopi : bool, optional
+            If True, wrap phase into [0, 2*pi) instead of the default (-pi, pi].
+
+        Returns
+        -------
+        ndarray
+            Phase profile, shape (Dy, Dx) if pol_index is given or pol==1,
+            otherwise shape (pol, Dy, Dx).
+        """
+        if pol_index is None:
+            field = self.field
+        else:
+            field = self.field[pol_index]
+        p = np.angle(field)
+        if twopi:
+            p = np.mod(p, 2*np.pi)
+        if self.pol == 1:
+            return p[0]
+        return p
+    
+
+    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): 
+        """
+        Calculate the intensity-weighted spatial standard deviation
+        along x and y.
+
+        Parameters 
+        ---------- 
+        pol_index : int, optional 
+            Polarization component to use; None uses total intensity. 
+
+        Returns
+        -------
+        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.
+
+        Parameters
+        ----------
+        pol_index : int, optional
+            Polarization component to use; None uses total intensity.
+
+        Returns
+        -------
+        float
+            Intensity-weighted radial standard deviation.
+        """
+        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:
+        """
+        Parameters
+        ----------
+        ang_min : float
+            Minimum angle (radians) defining the angular wedge.
+        ang_max : float
+            Maximum angle (radians) defining the angular wedge.
+        pol_index : int, optional
+            Polarization component to extract the section from.
+
+        Returns
+        -------
+        ndarray
+            Complex field values restricted to the angular wedge [ang_min, ang_max].
+        """
+        return get_section(self, ang_min, ang_max, pol_index = pol_index)
+    
+    def int_section(self, ang_min:float, ang_max:float, pol_index:int=0)-> np.ndarray:
+        """
+        Parameters
+        ----------
+        ang_min : float
+            Minimum angle (radians) defining the angular wedge.
+        ang_max : float
+            Maximum angle (radians) defining the angular wedge.
+        pol_index : int, optional
+            Polarization component to extract the section from.
+
+        Returns
+        -------
+        ndarray
+            Intensity |field|^2 within the angular wedge [ang_min, ang_max].
+        """
+        return np.abs(self.section(ang_min, ang_max, pol_index = pol_index))**2
+    
+    def Power_section(self, ang_min:float, ang_max:float, pol_index:int=0)-> float:
+        """
+        Parameters
+        ----------
+        ang_min : float
+            Minimum angle (radians) defining the angular wedge.
+        ang_max : float
+            Maximum angle (radians) defining the angular wedge.
+        pol_index : int, optional
+            Polarization component to compute power for.
+
+        Returns
+        -------
+        float
+            Optical power contained within the angular wedge [ang_min, ang_max].
+        """
+        return np.sum(np.abs(self.section(ang_min, ang_max, pol_index = pol_index))**2*(4*self.nix/self.Dx)*(self.niy/self.Dy))
+    
+    def norm_beam(self)-> object:                                       
+        """
+        Returns
+        -------
+        Beam
+            self, with field rescaled in place so that self.Power() == 1.
+        """
+        self.field = self.field/np.sqrt(self.Power())
+        return self
+    
+    def Max_int1(self)-> object:                                         
+        """
+        Returns
+        -------
+        Beam
+            self, with field rescaled in place so that the peak intensity equals 1.
+        """
+        self.field = self.field/np.sqrt(np.max(self.int_profile()))
+        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.5 → structured_optics-0.6}/structured_optics/hologram.py

@@ -1,7 +1,6 @@
-from structured_optics.struct_opt import *
 import numpy as np
-from structured_optics.utils import *
-import time
+from .utils import inv_J0, inv_J1, inv_sinc
+
 
 
 def slm_hologram(Beam, x_grating, y_grating, method, input_beam, eps, max_range):
@@ -40,7 +39,7 @@ def slm_hologram(Beam, x_grating, y_grating, method, input_beam, eps, max_range)
     elif method == 'bessel1':
         H = inv_J1(A_rel)*np.sin(phi_relg)
     else:
-        print('Error! method must be simple, g_holo, davis, bolduc, bessel0 or bessel1.')
+        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)