ptychodus 1.0__py3-none-any.whl

ptychodus/__init__.py

@@ -0,0 +1,19 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version('ptychodus')
+except PackageNotFoundError:
+    pass
+
+try:
+    from .ptychodus_stream_processor import PtychodusAdImageProcessor
+except ModuleNotFoundError:
+    pass
+
+__all__ = [
+    'api',
+    'model',
+    'view',
+    'controller',
+    'PtychodusAdImageProcessor',
+]

ptychodus/__main__.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+from pathlib import Path
+import argparse
+import logging
+import sys
+
+from ptychodus.model import ModelCore
+import ptychodus
+
+logger = logging.getLogger(__name__)
+
+
+def version_string() -> str:
+    return f'{ptychodus.__name__.title()} ({ptychodus.__version__})'
+
+
+def verify_all_arguments_parsed(parser: argparse.ArgumentParser, argv: list[str]) -> None:
+    if argv:
+        parser.error('unrecognized arguments: %s' % ' '.join(argv))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        prog=ptychodus.__name__.lower(),
+        description=f'{ptychodus.__name__} is a ptychography analysis application',
+    )
+    parser.add_argument(
+        '-b',
+        '--batch',
+        choices=('reconstruct', 'train'),
+        help='run action non-interactively',
+    )
+    parser.add_argument(
+        '-d',
+        '--dev',
+        action='store_true',
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        '--fluorescence-input',
+        metavar='FLUORESCENCE_INPUT_FILE',
+        type=argparse.FileType('r'),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        '--fluorescence-output',
+        metavar='FLUORESCENCE_OUTPUT_FILE',
+        type=argparse.FileType('w'),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        '-i',
+        '--input',
+        metavar='INPUT_FILE',
+        type=argparse.FileType('r'),
+        help='input file (batch mode)',
+    )
+    parser.add_argument(
+        '-o',
+        '--output',
+        metavar='OUTPUT_FILE',
+        type=argparse.FileType('w'),
+        help='output file (batch mode)',
+    )
+    parser.add_argument(
+        # preprocessed diffraction patterns file (batch mode)
+        '-p',
+        '--patterns',
+        metavar='PATTERNS_FILE',
+        type=argparse.FileType('r'),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        '-s',
+        '--settings',
+        metavar='SETTINGS_FILE',
+        help='use settings from file',
+        type=argparse.FileType('r'),
+    )
+    parser.add_argument(
+        '-v',
+        '--version',
+        action='version',
+        version=version_string(),
+    )
+
+    parsed_args, unparsed_args = parser.parse_known_args()
+    settings_file = Path(parsed_args.settings.name) if parsed_args.settings else None
+
+    with ModelCore(settings_file, is_developer_mode_enabled=parsed_args.dev) as model:
+        if parsed_args.patterns is not None:
+            patterns_file_path = Path(parsed_args.patterns.name)
+            model.workflow_api.import_assembled_patterns(patterns_file_path)
+
+        if parsed_args.batch is not None:
+            verify_all_arguments_parsed(parser, unparsed_args)
+
+            if parsed_args.input is None or parsed_args.output is None:
+                parser.error('Batch mode requires input and output arguments!')
+                return -1
+
+            action = parsed_args.batch
+            input_file_path = Path(parsed_args.input.name)
+            output_file_path = Path(parsed_args.output.name)
+            fluorescence_input_file_path: Path | None = None
+            fluorescence_output_file_path: Path | None = None
+
+            if parsed_args.fluorescence_input is not None:
+                fluorescence_input_file_path = Path(parsed_args.fluorescence_input.name)
+
+            if parsed_args.fluorescence_output is not None:
+                fluorescence_output_file_path = Path(parsed_args.fluorescence_output.name)
+
+            return model.batch_mode_execute(
+                action,
+                input_file_path,
+                output_file_path,
+                fluorescence_input_file_path=fluorescence_input_file_path,
+                fluorescence_output_file_path=fluorescence_output_file_path,
+            )
+
+        try:
+            from PyQt5.QtWidgets import QApplication
+        except ModuleNotFoundError:
+            logger.warning('PyQt5 not found.')
+            return 0
+
+        # QApplication expects the first argument to be the program name
+        app = QApplication(sys.argv[:1] + unparsed_args)
+        verify_all_arguments_parsed(parser, app.arguments()[1:])
+
+        from ptychodus.view import ViewCore
+
+        view = ViewCore()
+
+        from ptychodus.controller import ControllerCore
+
+        controller = ControllerCore(model, view, is_developer_mode_enabled=parsed_args.dev)
+        controller.show_main_window(version_string())
+
+        return app.exec()
+
+
+sys.exit(main())

ptychodus/api/fluorescence.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from .product import Product
+from .typing import RealArrayType
+
+
+@dataclass(frozen=True)
+class ElementMap:
+    name: str
+    counts_per_second: RealArrayType
+
+
+@dataclass(frozen=True)
+class FluorescenceDataset:
+    element_maps: Sequence[ElementMap]
+    counts_per_second_path: str
+    channel_names_path: str
+
+    # TODO need to communicate association between element map pixels and scan order.
+    #      integer-valued, same shape as counts_per_second
+    # scan_indexes: IntegerArray
+
+
+class FluorescenceEnhancingAlgorithm(ABC):
+    @abstractmethod
+    def enhance(self, dataset: FluorescenceDataset, product: Product) -> FluorescenceDataset:
+        pass
+
+
+class FluorescenceFileReader(ABC):
+    @abstractmethod
+    def read(self, file_path: Path) -> FluorescenceDataset:
+        """reads a fluorescence dataset from file"""
+        pass
+
+
+class FluorescenceFileWriter(ABC):
+    @abstractmethod
+    def write(self, file_path: Path, dataset: FluorescenceDataset) -> None:
+        """writes a fluorescence dataset to file"""
+        pass
+
+
+class UpscalingStrategy(ABC):
+    """Uses ptychography-corrected scan positions to remap element
+    concentrations from the regular scan grid to the upscaled grid"""
+
+    @abstractmethod
+    def __call__(self, emap: ElementMap, product: Product) -> ElementMap:
+        pass
+
+
+class DeconvolutionStrategy(ABC):
+    """Deconvolves the kernel from the accumulated array to obtain the
+    resolution-enhanced element map"""
+
+    @abstractmethod
+    def __call__(self, emap: ElementMap, product: Product) -> ElementMap:
+        pass

ptychodus/api/geometry.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Generic, TypeVar
+
+T = TypeVar('T', int, float, Decimal)
+
+
+@dataclass(frozen=True)
+class AffineTransform:
+    a00: float
+    a01: float
+    a02: float
+
+    a10: float
+    a11: float
+    a12: float
+
+    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)
+class PixelGeometry:
+    width_m: float
+    height_m: float
+
+    @property
+    def area_m2(self) -> float:
+        return self.width_m * self.height_m
+
+    @property
+    def aspect_ratio(self) -> float:
+        return self.width_m / self.height_m
+
+    def copy(self) -> PixelGeometry:
+        return PixelGeometry(
+            width_m=float(self.width_m),
+            height_m=float(self.height_m),
+        )
+
+
+@dataclass(frozen=True)
+class ImageExtent:
+    width_px: int
+    height_px: int
+
+    @property
+    def size(self) -> int:
+        """returns the number of pixels in the image"""
+        return self.width_px * self.height_px
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        """returns the image shape (height_px, width_px) tuple"""
+        return self.height_px, self.width_px
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ImageExtent):
+            return self.shape == other.shape
+
+        return False
+
+
+@dataclass(frozen=True)
+class Point2D:
+    x: float
+    y: float
+
+
+@dataclass(frozen=True)
+class Line2D:
+    begin: Point2D
+    end: Point2D
+
+    def lerp(self, alpha: float) -> Point2D:
+        beta = 1 - alpha
+        x = beta * self.begin.x + alpha * self.end.x
+        y = beta * self.begin.y + alpha * self.end.y
+        return Point2D(x, y)
+
+
+@dataclass(frozen=True)
+class Box2D:
+    x: float
+    y: float
+    width: float
+    height: float
+
+    @property
+    def x_begin(self) -> float:
+        return self.x
+
+    @property
+    def x_end(self) -> float:
+        return self.x + self.width
+
+    @property
+    def y_begin(self) -> float:
+        return self.y
+
+    @property
+    def y_end(self) -> float:
+        return self.y + self.height
+
+
+class Interval(Generic[T]):
+    def __init__(self, lower: T, upper: T) -> None:
+        self.lower: T = lower
+        self.upper: T = upper
+
+    @classmethod
+    def create_proper(cls, a: T, b: T) -> Interval[T]:
+        if b < a:
+            return Interval[T](b, a)
+        else:
+            return Interval[T](a, b)
+
+    @property
+    def is_empty(self) -> bool:
+        return self.upper < self.lower
+
+    def clamp(self, value: T) -> T:
+        return max(self.lower, min(value, self.upper))
+
+    def hull(self, value: Interval[T] | T) -> Interval[T]:
+        if isinstance(value, Interval):
+            return Interval[T](min(self.lower, value.lower), max(self.upper, value.upper))
+        else:
+            return Interval[T](min(self.lower, value), max(self.upper, value))
+
+    @property
+    def length(self) -> T:
+        return self.upper - self.lower
+
+    @property
+    def midrange(self) -> T:
+        total = self.lower + self.upper
+        return total // 2 if isinstance(total, int) else total / 2
+
+    def copy(self) -> Interval[T]:
+        return Interval[T](self.lower, self.upper)
+
+    def __contains__(self, item: T) -> bool:
+        return self.lower <= item and item < self.upper
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}({self.lower}, {self.upper})'

ptychodus/api/object.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy
+
+from .geometry import ImageExtent, PixelGeometry
+from .scan import ScanPoint
+from .typing import ComplexArrayType
+
+
+@dataclass(frozen=True)
+class ObjectCenter:
+    position_x_m: float
+    position_y_m: float
+
+    def copy(self) -> ObjectCenter:
+        return ObjectCenter(
+            position_x_m=float(self.position_x_m),
+            position_y_m=float(self.position_y_m),
+        )
+
+
+@dataclass(frozen=True)
+class ObjectPoint:
+    index: int
+    position_x_px: float
+    position_y_px: float
+
+
+@dataclass(frozen=True)
+class ObjectGeometry:
+    width_px: int
+    height_px: int
+    pixel_width_m: float
+    pixel_height_m: float
+    center_x_m: float
+    center_y_m: float
+
+    @property
+    def width_m(self) -> float:
+        return self.width_px * self.pixel_width_m
+
+    @property
+    def height_m(self) -> float:
+        return self.height_px * self.pixel_height_m
+
+    @property
+    def minimum_x_m(self) -> float:
+        return self.center_x_m - self.width_m / 2.0
+
+    @property
+    def minimum_y_m(self) -> float:
+        return self.center_y_m - self.height_m / 2.0
+
+    def get_pixel_geometry(self) -> PixelGeometry:
+        return PixelGeometry(
+            width_m=self.pixel_width_m,
+            height_m=self.pixel_height_m,
+        )
+
+    def get_center(self) -> ObjectCenter:
+        return ObjectCenter(
+            position_x_m=self.center_x_m,
+            position_y_m=self.center_y_m,
+        )
+
+    def map_object_point_to_scan_point(self, point: ObjectPoint) -> ScanPoint:
+        rx_px = self.width_px / 2
+        ry_px = self.height_px / 2
+        dx_m = self.pixel_width_m
+        dy_m = self.pixel_height_m
+
+        x_m = self.center_x_m + dx_m * (point.position_x_px - rx_px)
+        y_m = self.center_y_m + dy_m * (point.position_y_px - ry_px)
+
+        return ScanPoint(point.index, x_m, y_m)
+
+    def map_scan_point_to_object_point(self, point: ScanPoint) -> ObjectPoint:
+        rx_px = self.width_px / 2
+        ry_px = self.height_px / 2
+        dx_m = self.pixel_width_m
+        dy_m = self.pixel_height_m
+
+        x_px = (point.position_x_m - self.center_x_m) / dx_m + rx_px
+        y_px = (point.position_y_m - self.center_y_m) / dy_m + ry_px
+
+        return ObjectPoint(point.index, x_px, y_px)
+
+    def contains(self, geometry: ObjectGeometry) -> bool:
+        dx = self.center_x_m - geometry.center_x_m
+        dy = self.center_y_m - geometry.center_y_m
+        dw = self.width_m - geometry.width_m
+        dh = self.height_m - geometry.height_m
+        return abs(dx) <= dw and abs(dy) <= dh
+
+
+class ObjectGeometryProvider(ABC):
+    @abstractmethod
+    def get_object_geometry(self) -> ObjectGeometry:
+        pass
+
+
+class Object:
+    def __init__(
+        self,
+        array: ComplexArrayType | None,
+        pixel_geometry: PixelGeometry | None,
+        center: ObjectCenter | None,
+        layer_spacing_m: Sequence[float] = [],
+    ) -> None:
+        if array is None:
+            self._array: ComplexArrayType = numpy.zeros((1, 0, 0), dtype=complex)
+        elif numpy.iscomplexobj(array):
+            match array.ndim:
+                case 2:
+                    self._array = array[numpy.newaxis, ...]
+                case 3:
+                    self._array = array
+                case _:
+                    raise ValueError('Object must be 2- or 3-dimensional ndarray.')
+        else:
+            raise TypeError('Object must be a complex-valued ndarray')
+
+        self._pixel_geometry = pixel_geometry
+        self._center = center
+        self._layer_spacing_m = layer_spacing_m
+
+        expected_layers = self._array.shape[-3]
+        actual_layers = len(layer_spacing_m) + 1
+
+        if actual_layers != expected_layers:
+            raise ValueError(f'Expected {expected_layers} layers; got {actual_layers}!')
+
+    def copy(self) -> Object:
+        return Object(
+            array=self._array.copy(),
+            pixel_geometry=None if self._pixel_geometry is None else self._pixel_geometry.copy(),
+            center=None if self._center is None else self._center.copy(),
+            layer_spacing_m=list(self._layer_spacing_m),
+        )
+
+    def get_array(self) -> ComplexArrayType:
+        return self._array
+
+    @property
+    def dtype(self) -> numpy.dtype:
+        return self._array.dtype
+
+    @property
+    def nbytes(self) -> int:
+        return self._array.nbytes
+
+    @property
+    def width_px(self) -> int:
+        return self._array.shape[-1]
+
+    @property
+    def height_px(self) -> int:
+        return self._array.shape[-2]
+
+    @property
+    def num_layers(self) -> int:
+        return self._array.shape[-3]
+
+    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:
+        if self._center is None:
+            raise ValueError('Missing object center!')
+
+        return self._center
+
+    def get_geometry(self) -> ObjectGeometry:
+        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_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) -> ComplexArrayType:
+        return self._array[number, :, :]
+
+    def get_layers_flattened(self) -> ComplexArrayType:
+        return numpy.prod(self._array, axis=-3)
+
+    @property
+    def layer_spacing_m(self) -> Sequence[float]:
+        return self._layer_spacing_m
+
+    def get_total_thickness_m(self) -> float:
+        return sum(self._layer_spacing_m)
+
+
+class ObjectFileReader(ABC):
+    @abstractmethod
+    def read(self, file_path: Path) -> Object:
+        """reads an object from file"""
+        pass
+
+
+class ObjectFileWriter(ABC):
+    @abstractmethod
+    def write(self, file_path: Path, object_: Object) -> None:
+        """writes an object to file"""
+        pass

ptychodus/api/observer.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Generic, TypeVar
+
+__all__ = [
+    'Observer',
+    'Observable',
+    'SequenceObserver',
+    'ObservableSequence',
+]
+
+T = TypeVar('T')
+
+
+class Observer(ABC):
+    @abstractmethod
+    def _update(self, observable: Observable) -> None:
+        pass
+
+
+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:
+            self._observer_list.append(observer)
+
+    def remove_observer(self, observer: Observer) -> None:
+        try:
+            self._observer_list.remove(observer)
+        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)
+
+
+class SequenceObserver(Generic[T], ABC):
+    @abstractmethod
+    def handle_item_inserted(self, index: int, item: T) -> None:
+        pass
+
+    @abstractmethod
+    def handle_item_changed(self, index: int, item: T) -> None:
+        pass
+
+    @abstractmethod
+    def handle_item_removed(self, index: int, item: T) -> None:
+        pass
+
+
+class ObservableSequence(Sequence[T]):
+    def __init__(self) -> None:
+        self._observer_list: list[SequenceObserver[T]] = list()
+
+    def add_observer(self, observer: SequenceObserver[T]) -> None:
+        if observer not in self._observer_list:
+            self._observer_list.append(observer)
+
+    def remove_observer(self, observer: SequenceObserver[T]) -> None:
+        try:
+            self._observer_list.remove(observer)
+        except ValueError:
+            pass
+
+    def notify_observers_item_inserted(self, index: int, item: T) -> None:
+        for observer in self._observer_list:
+            observer.handle_item_inserted(index, item)
+
+    def notify_observers_item_changed(self, index: int, item: T) -> None:
+        for observer in self._observer_list:
+            observer.handle_item_changed(index, item)
+
+    def notify_observers_item_removed(self, index: int, item: T) -> None:
+        for observer in self._observer_list:
+            observer.handle_item_removed(index, item)