Basic OPR support (#108)

- implement basic OPR support
- prototype affine transform estimation algorithm
- auto estimate photon counts
- add macro to attempt all scan transforms

Author: stevehenke

src/ptychodus/api/geometry.py

@@ -16,10 +16,10 @@ class AffineTransform:
     a11: float
     a12: float
 
-    def __call__(self, x: float, y: float) -> tuple[float, float]:
-        xp = self.a00 * x + self.a01 * y + self.a02
-        yp = self.a10 * x + self.a11 * y + self.a12
-        return xp, yp
+    def __call__(self, y: float, x: float) -> tuple[float, float]:
+        yp = self.a00 * y + self.a01 * x + self.a02
+        xp = self.a10 * y + self.a11 * x + self.a12
+        return yp, xp
 
 
 @dataclass(frozen=True)
@@ -37,9 +37,6 @@ def copy(self) -> PixelGeometry:
             height_m=float(self.height_m),
         )
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.width_m}, {self.height_m})'
-
 
 @dataclass(frozen=True)
 class ImageExtent:
@@ -62,18 +59,12 @@ def __eq__(self, other: object) -> bool:
 
         return False
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.width_px}, {self.height_px})'
-
 
 @dataclass(frozen=True)
 class Point2D:
     x: float
     y: float
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.x}, {self.y})'
-
 
 @dataclass(frozen=True)
 class Line2D:
@@ -86,9 +77,6 @@ def lerp(self, alpha: float) -> Point2D:
         y = beta * self.begin.y + alpha * self.end.y
         return Point2D(x, y)
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.begin}, {self.end})'
-
 
 @dataclass(frozen=True)
 class Box2D:
@@ -113,9 +101,6 @@ def y_begin(self) -> float:
     def y_end(self) -> float:
         return self.y + self.height
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.x}, {self.y}, {self.width}, {self.height})'
-
 
 class Interval(Generic[T]):
     def __init__(self, lower: T, upper: T) -> None:

src/ptychodus/api/object.py

@@ -3,15 +3,12 @@
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, TypeAlias
 
 import numpy
-import numpy.typing
 
 from .geometry import ImageExtent, PixelGeometry
 from .scan import ScanPoint
-
-ObjectArrayType: TypeAlias = numpy.typing.NDArray[numpy.complexfloating[Any, Any]]
+from .typing import ComplexArrayType
 
 
 @dataclass(frozen=True)
@@ -25,9 +22,6 @@ def copy(self) -> ObjectCenter:
             position_y_m=float(self.position_y_m),
         )
 
-    def __repr__(self) -> str:
-        return f'{type(self).__name__}({self.position_x_m}, {self.position_y_m})'
-
 
 @dataclass(frozen=True)
 class ObjectPoint:
@@ -112,13 +106,13 @@ def get_object_geometry(self) -> ObjectGeometry:
 class Object:
     def __init__(
         self,
-        array: ObjectArrayType | None,
+        array: ComplexArrayType | None,
         pixel_geometry: PixelGeometry | None,
         center: ObjectCenter | None,
         layer_distance_m: Sequence[float] = [],
     ) -> None:
         if array is None:
-            self._array: ObjectArrayType = numpy.zeros((1, 0, 0), dtype=complex)
+            self._array: ComplexArrayType = numpy.zeros((1, 0, 0), dtype=complex)
         elif numpy.iscomplexobj(array):
             match array.ndim:
                 case 2:
@@ -148,7 +142,7 @@ def copy(self) -> Object:
             layer_distance_m=list(self._layer_distance_m),
         )
 
-    def get_array(self) -> ObjectArrayType:
+    def get_array(self) -> ComplexArrayType:
         return self._array
 
     @property
@@ -171,40 +165,35 @@ def height_px(self) -> int:
     def num_layers(self) -> int:
         return self._array.shape[-3]
 
-    def get_pixel_geometry(self) -> PixelGeometry | None:
+    def get_pixel_geometry(self) -> PixelGeometry:
+        if self._pixel_geometry is None:
+            raise ValueError('Missing object pixel geometry!')
+
         return self._pixel_geometry
 
-    def get_center(self) -> ObjectCenter | None:
+    def get_center(self) -> ObjectCenter:
+        if self._center is None:
+            raise ValueError('Missing object center!')
+
         return self._center
 
     def get_geometry(self) -> ObjectGeometry:
-        pixel_width_m = 0.0
-        pixel_height_m = 0.0
-
-        if self._pixel_geometry is not None:
-            pixel_width_m = self._pixel_geometry.width_m
-            pixel_height_m = self._pixel_geometry.height_m
-
-        center_x_m = 0.0
-        center_y_m = 0.0
-
-        if self._center is not None:
-            center_x_m = self._center.position_x_m
-            center_y_m = self._center.position_y_m
+        pixel_geometry = self.get_pixel_geometry()
+        center = self.get_center()
 
         return ObjectGeometry(
             width_px=self.width_px,
             height_px=self.height_px,
-            pixel_width_m=pixel_width_m,
-            pixel_height_m=pixel_height_m,
-            center_x_m=center_x_m,
-            center_y_m=center_y_m,
+            pixel_width_m=pixel_geometry.width_m,
+            pixel_height_m=pixel_geometry.height_m,
+            center_x_m=center.position_x_m,
+            center_y_m=center.position_y_m,
         )
 
-    def get_layer(self, number: int) -> ObjectArrayType:
+    def get_layer(self, number: int) -> ComplexArrayType:
         return self._array[number, :, :]
 
-    def get_layers_flattened(self) -> ObjectArrayType:
+    def get_layers_flattened(self) -> ComplexArrayType:
         return numpy.prod(self._array, axis=-3)
 
     @property

src/ptychodus/api/observer.py

@@ -22,6 +22,8 @@ def _update(self, observable: Observable) -> None:
 class Observable:
     def __init__(self) -> None:
         self._observer_list: list[Observer] = list()
+        self._block_notifications = False
+        self._pending_notify = False
 
     def add_observer(self, observer: Observer) -> None:
         if observer not in self._observer_list:
@@ -33,7 +35,18 @@ def remove_observer(self, observer: Observer) -> None:
         except ValueError:
             pass
 
+    def block_notifications(self, block: bool) -> None:
+        self._block_notifications = block
+
+        if self._pending_notify:
+            self.notify_observers()
+            self._pending_notify = False
+
     def notify_observers(self) -> None:
+        if self._block_notifications:
+            self._pending_notify = True
+            return
+
         for observer in self._observer_list:
             observer._update(self)
 

src/ptychodus/api/patterns.py

@@ -11,7 +11,6 @@
 from .geometry import ImageExtent, PixelGeometry
 from .tree import SimpleTreeNode
 
-BooleanArrayType: TypeAlias = numpy.typing.NDArray[numpy.bool_]
 PatternDataType: TypeAlias = numpy.typing.NDArray[numpy.integer[Any]]
 PatternIndexesType: TypeAlias = numpy.typing.NDArray[numpy.integer[Any]]