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

structured_optics-0.4.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, <Your Altilano Cristino Barbosa>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

structured_optics-0.4.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: structured_optics
+Version: 0.4.1
+Summary: Package for Structured Light simulation
+Author: Altilano C. Barbosa
+License-Expression: BSD-3-Clause
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: screeninfo
+Dynamic: license-file
+
+# 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-0.4.1/README.md

@@ -0,0 +1,79 @@
+# 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-0.3 → structured_optics-0.4.1}/pyproject.toml

@@ -4,8 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structured_optics"
-version = "0.3"
+version = "0.4.1"
 description = "Package for Structured Light simulation"
+readme = "README.md"
+license = "BSD-3-Clause"
 requires-python = ">=3.9"
 authors = [
     { name = "Altilano C. Barbosa" }
@@ -14,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()
+
+