diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 52592dc..b33f7dd 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -37,6 +37,11 @@ jobs: cd docs myst build --html touch _build/html/.nojekyll + - name: Delete old GitHub Pages artifact + uses: geekyeggo/delete-artifact@v2 + with: + name: github-pages + failOnError: false - name: Upload artifact uses: actions/upload-pages-artifact@v3 with: @@ -44,4 +49,3 @@ jobs: - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v4 - diff --git a/README.md b/README.md index 4ad9aac..b7a3224 100644 --- a/README.md +++ b/README.md @@ -50,18 +50,15 @@ See - docs/dev_guide.md ### Core installation (simulation mode) -```bash -pip install --find-links ./stubs -e . -``` - -or with `uv`: - ```bash uv sync ``` -This installs `asyncroscopy` and all core dependencies. AutoScript is not required—the -framework will fall back to simulated acquisition automatically. +This installs `asyncroscopy` and all core dependencies. The vendor wheels are +local, version-pinned, and resolved via `[tool.uv.sources]` in `pyproject.toml` +(AutoScript under `stubs/AutoScript_v_1.17/`, PyJEM under +`stubs/PyJEM_v_1.3.0.3564/`). AutoScript/PyJEM hardware is not required—the +framework falls back to simulated acquisition automatically. ### Hardware installation (Thermo Fisher AutoScript) diff --git a/asyncroscopy/data/data_writer.py b/asyncroscopy/data/data_writer.py index a21909a..215161b 100644 --- a/asyncroscopy/data/data_writer.py +++ b/asyncroscopy/data/data_writer.py @@ -9,6 +9,7 @@ import h5py import numpy as np +import tifffile DEFAULT_ACQUISITION_DIR = "outputs/tiled_acquisitions" @@ -35,6 +36,21 @@ def acquisition_filename( return directory / f"{acquisition_type}_{detector}_{stamp}.{extension.lower().lstrip('.')}" +def _write_tiff(source, path: Path, attrs: dict | None = None) -> None: + """Write one image to ``path`` as TIFF. + + AutoScript adorned images save themselves natively (embedding their own + metadata); anything else is a raw array (JEOL/twin) written via tifffile, + with ``attrs`` (e.g. JEOL's get_detectorsetting() dict) json-encoded into the + TIFF ImageDescription tag so the provenance survives the format. + """ + if hasattr(source, "save"): # adorned images from AutoScript have a save method + source.save(str(path)) + else: + array = source.data if hasattr(source, "data") and not isinstance(source, np.ndarray) else source + tifffile.imwrite(str(path), np.asarray(array), description=json.dumps(attrs) if attrs else None) + + def save_acquisition( device, data_server, @@ -44,11 +60,31 @@ def save_acquisition( dataset_name: str = "image", dataset_attrs: dict | list[dict] | None = None, file_attrs: dict | None = None, + output_format: str = ".h5", ) -> str: - """Save one acquisition to one HDF5 file and return its DATA/Tiled key.""" + """Save one acquisition and return its DATA/Tiled key. + + ``.h5`` writes all detectors into one stacked file; ``.tiff`` writes one + file per detector sharing a timestamp (TIFF cannot stack), registering each. + """ + if output_format not in (".h5", ".tiff"): + raise ValueError(f"Unsupported output_format {output_format!r}; expected '.h5' or '.tiff'") detector_list = list(detectors) if isinstance(detectors, (list, tuple)) else [detectors] data_list = list(data) if isinstance(data, (list, tuple)) else [data] attrs_list = dataset_attrs if isinstance(dataset_attrs, list) else [dataset_attrs] * len(data_list) + + if output_format == ".tiff": + save_dir = data_server.save_path if data_server is not None else DEFAULT_ACQUISITION_DIR + directory = Path(save_dir).expanduser() + directory.mkdir(parents=True, exist_ok=True) + stem = f"{acquisition_type}_{datetime.now().strftime('%Y%m%dT%H%M%S%f')}" + for index, (source, detector) in enumerate(zip(data_list, detector_list)): + path = directory / f"{stem}_{detector}.tiff" + _write_tiff(source, path, attrs_list[index]) + if data_server is not None: + data_server.register_path(str(path)) + return stem + has_labeled_datasets = len(detector_list) > 1 or len(data_list) > 1 detector_label = "_".join([str(detector) for detector in detector_list]) path = acquisition_filename(device, acquisition_type, detector_label, data_server) @@ -98,3 +134,6 @@ def save_acquisition_hdf5(path: str | Path, datasets: list[dict], file_attrs: di if key in dset.attrs: key = f"{key}_{len(dset.attrs)}" dset.attrs[key] = elem.text.strip() + elif isinstance(metadata, dict): + for key, value in metadata.items(): + dset.attrs[key] = value if isinstance(value, (str, int, float, bool, np.number)) else json.dumps(value) diff --git a/asyncroscopy/instruments/electron_microscope/auto_script.py b/asyncroscopy/instruments/electron_microscope/auto_script.py index 14f3d98..67e161d 100644 --- a/asyncroscopy/instruments/electron_microscope/auto_script.py +++ b/asyncroscopy/instruments/electron_microscope/auto_script.py @@ -18,8 +18,7 @@ import math import time -from datetime import datetime -from pathlib import Path +import json import numpy as np import tango @@ -250,44 +249,16 @@ def register_stage(self): # ------------------------------------------------------------------ # Internal acquisition helpers # ------------------------------------------------------------------ - def _persist(self, adorned, acquisition_type, detector, data_server, dataset_name="image"): - """Save acquired images in the format requested by the SCAN device. - """ - scan = self._detector_proxies.get("scan") - fmt = scan.output_format if scan is not None else ".h5" # ".h5" default - if fmt == ".h5": - return save_acquisition(self, data_server, acquisition_type, detector, adorned, dataset_name=dataset_name) - if fmt != ".tiff": - raise ValueError(f"Unsupported output_format {fmt!r}; expected '.h5' or '.tiff'") - - # .tiff → AutoScript native save, one file per detector sharing one stamp - images = list(adorned) if isinstance(adorned, (list, tuple)) else [adorned] - detectors = list(detector) if isinstance(detector, (list, tuple)) else [detector] - if len(images) != len(detectors): - raise ValueError(f"Got {len(images)} images for {len(detectors)} detector(s) {detectors}") - - save_dir = data_server.save_path if data_server is not None else DEFAULT_ACQUISITION_DIR - directory = Path(save_dir).expanduser() - directory.mkdir(parents=True, exist_ok=True) - stamp = datetime.now().strftime("%Y%m%dT%H%M%S%f") - stem = f"{acquisition_type}_{stamp}" - # AutoScript returns images in the requested detector order (assumed; verify on hardware) - for img, det in zip(images, detectors): - path = directory / f"{stem}_{det}.tiff" - img.save(str(path)) - if data_server is not None: - data_server.register_path(str(path)) - return stem - def _acquire_scanned_image( self, imsize: int, dwell_time: float, detector_list: list[str] = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], + output_format: str = ".h5", ) -> str: """ - Call AutoScript scanned image acquisition, save one HDF5 file, and return its DATA/Tiled key. + Call AutoScript scanned image acquisition, save it, and return its DATA/Tiled key. """ detector_list = [d.upper() for d in detector_list] settings = StemAcquisitionSettings(dwell_time=dwell_time, detector_types=detector_list, size=imsize, region=Region(RegionCoordinateSystem.RELATIVE, Rectangle(*scan_region))) @@ -295,18 +266,18 @@ def _acquire_scanned_image( if not isinstance(adorned, list): adorned = [adorned] data_server = self._detector_proxies.get("data") - return self._persist(adorned, "stem_image", detector_list, data_server) + return save_acquisition(self, data_server, "stem_image", detector_list, adorned, output_format=output_format) def _acquire_camera_image(self, imsize: int, exposure_time: float, detector: str, readout_area: str) -> str: """ - Call AutoScript acquisition, save the adorned image, and return its path. + Call AutoScript acquisition, save the adorned image, and return its DATA/Tiled key. this is the advanced version """ settings = CameraAcquisitionSettings(camera_detector=detector, size=imsize, exposure_time=exposure_time, fixed_readout_area=readout_area, frame_combining=1) adorned = self._microscope.acquisition.acquire_camera_image_advanced(settings) data_server = self._detector_proxies.get("data") - return self._persist(adorned, "camera_image", str(detector), data_server) + return save_acquisition(self, data_server, "camera_image", str(detector), adorned) def _acquire_scanned_data_advanced(self, imsize: int, dwell_time: float, detector: str, scan_region: list[float]) -> str: """ @@ -379,9 +350,11 @@ def _set_defocus(self, defocus) -> None: def _get_defocus(self) -> float: """Get defocus in meters.""" - return self._microscope.optics.defocus + return float(self._microscope.optics.defocus) + - def _caibrate_screen_current(self) -> None: + def _calibrate_screen_current(self) -> None: + """ calibrate screen current with monchromator focus""" original_gun_lens = self._microscope.optics.monochromator.focus gun_lens_series = np.linspace(10, 150, 15) @@ -411,7 +384,7 @@ def _set_screen_current(self, current) -> None: self._microscope.optics.monochromator.focus = float(x_real) else: self.warn_stream("Screen current calibration not available. running calibration (should take 15 seconds).") - self._caibrate_screen_current() + self._calibrate_screen_current() poly_func = self.screen_current_calibration adjusted_poly = poly_func - current @@ -443,6 +416,40 @@ def _get_stage(self): return position else: return position[:4] + + + def _get_status(self): + status = {'system': self._microscope.service.system.name, + 'vacuum': self._microscope.vacuum.state, + 'column_valves': self._microscope.vacuum.column_valves.state, + 'is_accelerator_on': self._microscope.optics.is_accelerator_on, + 'acceleration_voltage': self._microscope.optics.acceleration_voltage.value, + 'optical_mode': self._microscope.optics.optical_mode, + 'illumination_mode': self._microscope.optics.illumination_mode, + 'objective_lens_mode': self._microscope.optics.objective_lens_mode, + 'projector_mode': self._microscope.optics.projector_mode, + #'convergence_angle': self._microscope.optics.convergence_angle, + 'spot_size': self._microscope.optics.spot_size_index, + 'beam_stopper': self._microscope.optics.beam_stopper.insertion_state, + 'beam_blanker': self._microscope.optics.blanker.is_beam_blanked, + 'is_eftem_on': self._microscope.optics.is_eftem_on, + } + if self._microscope.optics.optical_mode == 'Stem': + status['scan_rotation'] = self._microscope.optics.scan_rotation + status['scan_field_of_view'] = self._microscope.optics.scan_field_of_view + for mechanism_type in self._microscope.optics.aperture_mechanisms.get_available(): + mechanism = self._microscope.optics.aperture_mechanisms.get_mechanism(mechanism_type) + if not mechanism.is_enabled: + status[mechanism_type] = 'Disabled' + elif mechanism.insertion_state == 'Retracted': + status[mechanism_type] = 'Retracted' + else: + status[mechanism_type] = mechanism.aperture.name + for deflector in self._microscope.optics.deflectors.get_available_deflectors(): + defl = self._microscope.optics.deflectors.get_deflector_value(deflector) + status[deflector] = [defl.x, defl.y] + + return json.dumps(status) def _move_stage(self, position) -> None: """Move stage to specified position [x, y, z, alpha, beta].""" @@ -459,7 +466,7 @@ def _move_stage(self, position) -> None: beta = None self._microscope.specimen.stage.absolute_move((x, y, z, alpha, beta)) - self._get_stage() # link the proxy with real state + # self._get_stage() # link the proxy with real state def _auto_focus(self): """Perform autofocus routine C1A1""" @@ -471,11 +478,51 @@ def _set_image_shift(self, shift): x_shift = float(shift[0]) y_shift = float(shift[1]) try: - self._microscope.optics.deflectors.beam_shift = (x_shift, y_shift) + if self._microscope.optics.optical_mode == 'Stem': + self._microscope.optics.deflectors.beam_shift = (x_shift, y_shift) + else: + self._microscope.optics.deflectors.image_shift = (x_shift, y_shift) except Exception as e: - self.error_stream(f"Failed to set beam shift: {e}") - + self.error_stream(f"Failed to set image shift: {e}") + def _set_diffraction_shift(self, shift): + """Apply image shift in meters.""" + x_shift = float(shift[0]) + y_shift = float(shift[1]) + try: + if self._microscope.optics.projector_mode == 'Diffraction': + self._microscope.optics.deflectors.image_shift = (x_shift, y_shift) + except Exception as e: + self.error_stream(f"Failed to set diffraction shift: {e}") + + def _get_diffraction_shift(self): + if self._microscope.optics.optical_mode == 'Diffraction': + position = self._microscope.optics.deflectors.image_shift + return np.array([position.x, position.y]) + else: + return np.array([0, 0]) + + + def _get_image_shift(self): + if self._microscope.optics.optical_mode == 'Stem': + position = self._microscope.optics.deflectors.beam_shift + else: + position = self._microscope.optics.deflectors.image_shift + return np.array([position.x, position.y]) + + def _get_beam_tilt(self): + tilt = self._microscope.optics.deflectors.beam_tilt + return np.array([tilt .x, tilt.y]) + + def _set_beam_tilt(self, tilt): + """Apply beam tilt in radians.""" + x_tilt = float(tilt[0]) + y_tilt = float(tilt[1]) + try: + self._microscope.optics.deflectors.beam_tilt = (x_tilt, y_tilt) + except Exception as e: + self.error_stream(f"Failed to set beam tilt: {e}") + # ---------------------------------------------------------------------- # Server entry point # ---------------------------------------------------------------------- diff --git a/asyncroscopy/instruments/electron_microscope/digital_twin.py b/asyncroscopy/instruments/electron_microscope/digital_twin.py index 707e608..fc6bbc5 100644 --- a/asyncroscopy/instruments/electron_microscope/digital_twin.py +++ b/asyncroscopy/instruments/electron_microscope/digital_twin.py @@ -518,15 +518,16 @@ def _acquire_scanned_image( dwell_time: float, detector_list: list[str] = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], + output_format: str = ".h5", ) -> str: - """Simulate STEM acquisition, save HDF5 data with metadata, and return its DATA/Tiled key.""" + """Simulate STEM acquisition, save the data with metadata, and return its DATA/Tiled key.""" detector_list = [detector.upper() for detector in detector_list] data_server = self._detector_proxies.get("data") images = [] for detector in detector_list: image = self._render_stem_image(int(imsize), float(dwell_time), [detector]) images.append(image) - return save_acquisition(self, data_server, "stem_image", detector_list, images) + return save_acquisition(self, data_server, "stem_image", detector_list, images, output_format=output_format) def _simulate_spectrum(self, detector_name: str, exposure_time: float) -> dict[str, float]: """Simulate EDS spectrum acquisition at the current beam position weighted by surrounding particles.""" diff --git a/asyncroscopy/instruments/electron_microscope/digital_twin_diffraction.py b/asyncroscopy/instruments/electron_microscope/digital_twin_diffraction.py index 3c3096f..d0475a1 100644 --- a/asyncroscopy/instruments/electron_microscope/digital_twin_diffraction.py +++ b/asyncroscopy/instruments/electron_microscope/digital_twin_diffraction.py @@ -356,6 +356,7 @@ def _acquire_scanned_image( dwell_time: float, detector_list: list[str] = ['haadf'], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], + output_format: str = '.h5', ) -> str: image_size = int(self.overview_image_size) detector_list = [detector.upper() for detector in detector_list] @@ -369,7 +370,7 @@ def _acquire_scanned_image( 'sample_pixel_size_nm': float(FOV_NM / int(self.map_size)), } images = [self._render_stem_image(image_size, float(dwell_time), [detector]) for detector in detector_list] - return save_acquisition(self, data_server, 'stem_image', detector_list, images, dataset_attrs=attrs) + return save_acquisition(self, data_server, 'stem_image', detector_list, images, dataset_attrs=attrs, output_format=output_format) def _set_fov(self, fov) -> None: self.warn_stream('DigitalTwinDiffraction uses a fixed 500 nm field of view.') diff --git a/asyncroscopy/instruments/electron_microscope/electron_microscope.py b/asyncroscopy/instruments/electron_microscope/electron_microscope.py index 7fb262e..8dae70a 100644 --- a/asyncroscopy/instruments/electron_microscope/electron_microscope.py +++ b/asyncroscopy/instruments/electron_microscope/electron_microscope.py @@ -15,7 +15,7 @@ from typing import Optional import tango -from tango import AttrWriteType, DevEncoded, DevFloat, DevState, DevVarFloatArray, DevVarStringArray +from tango import AttrWriteType, DevEncoded, DevFloat, DevString, DevState, DevVarFloatArray, DevVarStringArray from tango.server import attribute, command, device_property from asyncroscopy.instruments.instrument import Instrument @@ -123,7 +123,7 @@ def acquire_spectrum(self, detector_name: str) -> str: def acquire_scanned_image(self, detector_list: list[str] = ['haadf']) -> str: """Acquire an image with scanning detectors and return its DATA/Tiled key.""" scan = self._detector_proxies.get('scan') - return self._acquire_scanned_image(scan.imsize, scan.dwell_time, detector_list, list(scan.scan_region)) + return self._acquire_scanned_image(scan.imsize, scan.dwell_time, detector_list, list(scan.scan_region), scan.output_format) @command(dtype_out=str) def acquire_scanned_data_advanced(self) -> str: @@ -207,6 +207,47 @@ def set_fov(self, fov): def get_fov(self): """Read the field of view for the next acquisition.""" return self._get_fov() + + @command(dtype_in=DevVarFloatArray) + def set_image_shift(self, shift): + """Set the image shift to [x_shift, y_shift] in meters.""" + self._set_image_shift(shift) + + @command(dtype_out=DevVarFloatArray) + def get_image_shift(self): + """Get the image shiftas [x, y] in m.""" + return self._get_image_shift() + + @command(dtype_out=DevVarFloatArray) + def get_beam_tilt(self): + """Get the current beam tilt as [alpha, beta] in radian.""" + return self._get_beam_tilt() + + @command(dtype_in=DevVarFloatArray) + def set_beam_tilt(self, tilt): + """Set the beam tilt to [x_tilt, y_tilt] in radian.""" + self._set_beam_tilt(tilt) + + @command(dtype_out=DevVarFloatArray) + def get_diffraction_shift(self): + """Get the current diffraction shift as [alpha, beta] in radian.""" + return self._get_diffraction_shift() + + @command(dtype_in=DevVarFloatArray) + def set_diffraction_shift(self, shift): + """Set the diffraction shift to [x_shift, y_shift] in radian.""" + self._set_diffraction_shift(shift) + + @command(dtype_out=DevString) + def get_status(self) -> str: + """ Get all status parameters""" + return self._get_status() + + @command() + def calibrate_screen_current(self): + """Set the screen current in pA.""" + self._calibrate_screen_current() + @command(dtype_in=DevFloat) def set_screen_current(self, current): @@ -220,12 +261,12 @@ def get_screen_current(self): @command(dtype_out=DevVarFloatArray) def get_stage(self): - """Get the current stage position as [x, y, z, alpha, beta].""" + """Get the current stage position as [x, y, z, alpha, beta] in m and radian respectively.""" return self._get_stage() - + @command(dtype_in=DevVarFloatArray) def move_stage(self, position): - """Move the stage to an absolute position [x, y, z, alpha, beta].""" + """Move the stage to an absolute position [x, y, z, alpha, beta] in m and radian respectively.""" self._move_stage(position) @command() @@ -233,11 +274,7 @@ def auto_focus(self): """Run the microscope's autofocus routine.""" self._auto_focus() - @command(dtype_in=DevVarFloatArray) - def set_image_shift(self, shift): - """Set the image shift to [x_shift, y_shift] in meters.""" - self._set_image_shift(shift) - + @abstractmethod def _acquire_scanned_image( self, @@ -245,6 +282,7 @@ def _acquire_scanned_image( dwell_time: float, detector_list: list[str] = ['haadf'], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], + output_format: str = '.h5', ) -> str: """Vendor-specific scanned image acquisition implementation.""" pass @@ -277,12 +315,17 @@ def _unblank_beam(self): def _set_defocus(self, defocus): pass + @abstractmethod def _get_defocus(self): pass @abstractmethod def _set_screen_current(self, current): pass + + @abstractmethod + def _calibrate_screen_current(self): + pass @abstractmethod def _get_screen_current(self): @@ -296,6 +339,30 @@ def _move_stage(self, position): def _get_stage(self): pass + @abstractmethod + def _get_image_shift(self): + pass + + @abstractmethod + def _get_beam_tilt(self): + pass + + @abstractmethod + def _set_beam_tilt(self,tilt): + pass + + @abstractmethod + def _get_diffraction_shift(self): + pass + + @abstractmethod + def _set_diffraction_shift(self, tilt): + pass + + @abstractmethod + def _get_status(self): + pass + @abstractmethod def _set_fov(self, fov): pass diff --git a/asyncroscopy/instruments/electron_microscope/jeol.py b/asyncroscopy/instruments/electron_microscope/jeol.py index 55e5c30..2c43d2a 100644 --- a/asyncroscopy/instruments/electron_microscope/jeol.py +++ b/asyncroscopy/instruments/electron_microscope/jeol.py @@ -5,9 +5,7 @@ and adapts it to the instrument-centered package layout. """ -from datetime import datetime -from pathlib import Path - +import numpy as np import tango from tango import DevState from tango.server import device_property @@ -15,6 +13,14 @@ from asyncroscopy.data.data_writer import DEFAULT_ACQUISITION_DIR, save_acquisition from asyncroscopy.instruments.electron_microscope.electron_microscope import ElectronMicroscope +# PyJEM imports -> this block will be removed after testing this on remote pc +try: + from PyJEM import detector + + _PYJEM_AVAILABLE = True +except ImportError: + _PYJEM_AVAILABLE = False + class JeolMicroscope(ElectronMicroscope): """ @@ -26,8 +32,10 @@ class JeolMicroscope(ElectronMicroscope): hardware_host = device_property( dtype=str, - default_value='10.46.217.241', - doc='Hostname or IP of the JEOL microscope control server.', + default_value='localhost', + doc='Hostname or IP of the JEOL microscope control server. PyJEM REST ' + 'clients default to localhost (the scope PC); set this to point at the ' + 'scope from another machine.', ) hardware_port = device_property( dtype=int, @@ -61,8 +69,37 @@ def _connect(self): self.set_state(DevState.ON) def _connect_hardware(self) -> None: - self._microscope = None - self.warn_stream('JEOL/PyJEM hardware connection is not implemented yet.') + """Point the PyJEM ``detector`` REST client at the JEOL control server. + + Unlike AutoScript (a client object you ``.connect()``), PyJEM's + ``detector`` module *is* the REST handle: configuring its target IP is + what makes acquisition talk to the scope. We store the module as + ``self._microscope`` to mirror the AutoScript device's connected handle. + + ``set_port`` is intentionally NOT called -- the detector REST service + has its own default port, distinct from ``hardware_port`` (which is + AutoScript's port and unused here). + """ + if not _PYJEM_AVAILABLE or self.testing_mode_bool: + self.warn_stream('PyJEM not available; running JEOL device in testing mode.') + return + try: + detector.set_ip(self.hardware_host) + # Health-check: get_attached_detector() is a REST round-trip to + # TEMCenter, so it raises if the server is unreachable. (The real + # PyJEM 1.3.0.3564 detector module has no check_connection() -- this + # is verified against the installed surface, not the docs.) An empty + # list is a reachable-but-unconfigured scope, not a failed connection. + attached = detector.get_attached_detector() + self._microscope = detector + self.info_stream( + f'Connected to JEOL/PyJEM detector server at {self.hardware_host}; ' + f'attached detectors: {attached}' + ) + except Exception as exc: + self.error_stream(f'JEOL/PyJEM connection failed: {exc}') + self.set_state(DevState.FAULT) + self._microscope = None def _connect_detector_proxies(self) -> None: addresses: dict[str, str] = { @@ -105,31 +142,16 @@ def _connect_detector_proxies(self) -> None: # ------------------------------------------------------------------ # Internal acquisition helpers # ------------------------------------------------------------------ - def _persist(self, adorned, acquisition_type, detector, data_server, dataset_name='image'): - """Save acquired images in the format requested by the SCAN device.""" - scan = self._detector_proxies.get('scan') - fmt = scan.output_format if scan is not None else '.h5' - if fmt == '.h5': - return save_acquisition(self, data_server, acquisition_type, detector, adorned, dataset_name=dataset_name) - if fmt != '.tiff': - raise ValueError(f"Unsupported output_format {fmt!r}; expected '.h5' or '.tiff'") - - images = list(adorned) if isinstance(adorned, (list, tuple)) else [adorned] - detectors = list(detector) if isinstance(detector, (list, tuple)) else [detector] - if len(images) != len(detectors): - raise ValueError(f'Got {len(images)} images for {len(detectors)} detector(s) {detectors}') - - save_dir = data_server.save_path if data_server is not None else DEFAULT_ACQUISITION_DIR - directory = Path(save_dir).expanduser() - directory.mkdir(parents=True, exist_ok=True) - stamp = datetime.now().strftime('%Y%m%dT%H%M%S%f') - stem = f'{acquisition_type}_{stamp}' - for img, det in zip(images, detectors): - path = directory / f'{stem}_{det}.tiff' - img.save(str(path)) - if data_server is not None: - data_server.register_path(str(path)) - return stem + @staticmethod + def _decode_rawdata(raw: bytes, width: int, height: int) -> np.ndarray: + """ + Decode a PyJEM ``snapshot_rawdata()`` byte buffer into a 2D image. + + PyJEM returns raw little-endian int16 bytes; the shape comes from the + detector's imaging area. Reshape order follows the PyJEM docs + (``(width, height)``) and is unverified for non-square scans. + """ + return np.frombuffer(raw, dtype=np.dtype(' str: - """Acquire a scanned image through the JEOL API.""" - tango.Except.throw_exception( - 'UnsupportedCommand', - 'JEOL scanned image acquisition is not implemented yet.', - '_acquire_scanned_image()', + """ + Acquire a STEM scan over the requested detectors via the PyJEM + ``detector`` module and return the saved acquisition's DATA/Tiled key. + + PyJEM acquisition is synchronous, so each detector is scanned in turn. + ``dwell_time`` is given in seconds; the PyJEM API takes microseconds. + """ + if not _PYJEM_AVAILABLE: + tango.Except.throw_exception( + 'UnsupportedCommand', + 'PyJEM is not installed; cannot acquire on JEOL hardware.', + '_acquire_scanned_image()', + ) + + detector_list = [d.upper() for d in detector_list] + full_frame = [0.0, 0.0, 1.0, 1.0] + images = [] + image_settings = [] + for name in detector_list: + det = detector.Detector(name) + if scan_region == full_frame: + det.set_scanmode(0) # full-frame Scan + det.set_imaging_area(imsize, imsize) + else: + extent = det.get_detectorsetting()['ImagingArea']['Width'] + left, top, right, bottom = scan_region + det.set_scanmode(3) # Area (sub-region) + det.set_areamode_imagingarea( + Width=int((right - left) * extent), + Height=int((bottom - top) * extent), + X=int(left * extent), + Y=int(top * extent), + ) + det.set_exposuretime_value(dwell_time * 1e6) # PyJEM API takes microseconds while AutoScript takes seconds -- Lets keep default to seconds + settings = det.get_detectorsetting() + area = settings['AreaModeImagingArea'] if scan_region != full_frame else settings['ImagingArea'] + pixels = self._decode_rawdata(det.snapshot_rawdata(), area['Width'], area['Height']) + images.append(pixels) + image_settings.append(settings) + + data_server = self._detector_proxies.get('data') + return save_acquisition( + self, data_server, 'stem_image', detector_list, images, + dataset_attrs=image_settings, output_format=output_format, ) def _acquire_spectrum(self, detector_name: str, exposure_time: float) -> str: diff --git a/configs/covalent-F200.yaml b/configs/covalent-F200.yaml new file mode 100644 index 0000000..147c645 --- /dev/null +++ b/configs/covalent-F200.yaml @@ -0,0 +1,38 @@ +# asyncroscopy server config — JEOL JEM-F200 (Covalent). +# Read by startup_scripts/run_servers.py. Mirrors covalent-talos.yaml but swaps +# the AutoScript instrument for the PyJEM-backed JeolMicroscope. +# +# uv run startup_scripts/run_servers.py --yaml configs/covalent-F200.yaml +# +# The instrument is served as 'asyncroscopy/instrument/default'. For the digital +# twin, use configs/DigitalTwin.yaml (real and simulated scopes are separate +# configs now). See configs/example.md for the full YAML shape. + +instrument: + class_name: JeolMicroscope + file: asyncroscopy/instruments/electron_microscope/jeol.py + description: "JEOL JEM-F200 (S)TEM via PyJEM" + hardware_host: 10.46.217.241 # F200 control-server IP; localhost when run on the scope PC + hardware_port: 9095 + timeout_seconds: 120 + +devices: + camera: { module_name: asyncroscopy.instruments.electron_microscope.detectors.camera } + data: { module_name: asyncroscopy.data.data } + eds: { module_name: asyncroscopy.instruments.electron_microscope.detectors.eds } + scan: { module_name: asyncroscopy.instruments.electron_microscope.hardware.scan } + stage: { module_name: asyncroscopy.instruments.electron_microscope.hardware.stage } + +tango: + host: 127.0.0.1 # set to the F200 PC's IP to reach it from another machine + port: 9094 + reset_database_file: false + +tiled: + host: 127.0.0.1 # set to the F200 PC's IP for remote notebook access + port: 9091 + acquisition_dir: outputs/tiled_acquisitions + autostart: true + register_on_startup: false + +device_timeout_seconds: 120 diff --git a/docs/Tiled_server/data_integration.md b/docs/Tiled_server/data_integration.md index 0c01458..4b1b5c2 100644 --- a/docs/Tiled_server/data_integration.md +++ b/docs/Tiled_server/data_integration.md @@ -12,6 +12,12 @@ Image acquisitions can instead write `.tiff` (Velox-compatible, one file per detector) via `scan.output_format = ".tiff"`; spectra and STEM data are always HDF5. +Vendors return two shapes and `save_acquisition` absorbs both: AutoScript adorned +images bundle pixels and metadata, while PyJEM (JEOL) returns raw pixels plus a +separate `get_detectorsetting()` dict passed as `dataset_attrs`. Metadata lands as +HDF5 attributes for `.h5`; for `.tiff`, adorned images save it natively while +raw-array vendors get the dict json-encoded into the TIFF `ImageDescription` tag. + Acquisition commands that feed this pipeline include `acquire_scanned_image`, `acquire_spectrum`, `acquire_camera_image`, `acquire_flucam_image`, and `acquire_scanned_data_advanced`. diff --git a/notebooks/02_Image_Acquisition.ipynb b/notebooks/02_Image_Acquisition.ipynb index bc71b15..9deac68 100644 --- a/notebooks/02_Image_Acquisition.ipynb +++ b/notebooks/02_Image_Acquisition.ipynb @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e489fc71", "metadata": {}, "outputs": [ @@ -65,14 +65,14 @@ "output_type": "stream", "text": [ "asyncroscopy/scan/default ON\n", - "asyncroscopy/microscope/default ON\n", + "asyncroscopy/instrument/default ON\n", "asyncroscopy/data/default ON\n" ] } ], "source": [ - "DB_HOST = \"10.46.217.241\"\n", - "# DB_HOST = \"localhost\"\n", + "# DB_HOST = \"10.46.217.241\"\n", + "DB_HOST = \"localhost\"\n", "DB_PORT = 9094\n", "\n", "os.environ[\"TANGO_HOST\"] = f\"{DB_HOST}:{DB_PORT}\"\n", @@ -80,7 +80,7 @@ "server_names = ['stage', 'scan', 'eds', 'camera', 'data', 'microscope']\n", "\n", "scan = tango.DeviceProxy(\"asyncroscopy/scan/default\")\n", - "microscope = tango.DeviceProxy(\"asyncroscopy/microscope/default\")\n", + "microscope = tango.DeviceProxy(\"asyncroscopy/instrument/default\")\n", "data = tango.DeviceProxy(\"asyncroscopy/data/default\")\n", "\n", "for proxy in [scan, microscope, data]:\n", @@ -99,23 +99,23 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "bc6f99b5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'host': '10.46.217.241',\n", + "{'host': 'localhost',\n", " 'port': 9091,\n", - " 'uri': 'http://10.46.217.241:9091',\n", + " 'uri': 'http://localhost:9091',\n", " 'save_path': 'outputs/tiled_acquisitions',\n", " 'tiled_server': 'yes',\n", " 'tiled_server_status': 'running; serving path; files register manually',\n", " 'tiled_server_serving': 'outputs/tiled_acquisitions'}" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "049625e7", "metadata": {}, "outputs": [ @@ -135,7 +135,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tiled keys: []\n" + "Tiled keys: ['stem_image_HAADF_20260602T074251210320.h5', 'stem_image_HAADF_20260603T151413278920.h5', 'stem_image_HAADF_BF-S_DF-S_20260603T151625188975.h5', \"stem_image_['HAADF']_20260604T123909936109.tiff\", 'stem_image_HAADF_20260604T124103341637.h5', \"stem_image_['HAADF']_20260604T124340133951.tiff\", \"stem_image_['HAADF']_20260604T124348937617.tiff\", 'stem_image_HAADF_20260604T132409986976.h5', 'stem_image_HAADF_BF-S_DF-S_20260604T132417689146.h5', 'stem_image_20260604T132426343082_HAADF.tiff', 'stem_image_20260604T132426343082_BF-S.tiff', 'stem_image_20260604T132426343082_DF-S.tiff', 'stem_image_HAADF_BF-S_DF-S_20260609T062554866939.h5', 'stem_image_20260609T062624415362_HAADF.tiff', 'stem_image_20260609T062624415362_BF-S.tiff', 'stem_image_20260609T062624415362_DF-S.tiff', 'stem_image_20260609T062647829208_HAADF.tiff', 'stem_image_20260609T062819076257_HAADF.tiff', 'stem_image_20260609T062819076257_BF-S.tiff', 'stem_image_20260609T062819076257_DF-S.tiff', 'stem_image_20260609T063326438939_HAADF.tiff', 'stem_image_HAADF_20260609T063359002375.h5', 'stem_image_HAADF_20260609T064830038665.h5', 'stem_image_HAADF_20260609T064859641107.h5', 'stem_image_HAADF_20260614T085359042817.h5']\n" ] } ], @@ -154,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "478b95f1", "metadata": {}, "outputs": [ @@ -189,25 +189,25 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "df598f37", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f19a72043d3a47a9996e5088e158fcd6", + "model_id": "eddbc25e67df4e9e95c7e591411ca7af", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -234,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "4442aab2", "metadata": {}, "outputs": [ @@ -243,217 +243,72 @@ "output_type": "stream", "text": [ "Metadata:\n", - "{'AccelerationVoltage': '200000',\n", - " 'AcquisitionDatetime': '2026-06-18T12:41:44.9605047Z',\n", - " 'AcquisitionStartDatetime': '2026-06-18T12:41:44Z',\n", - " 'Alpha': '-3.136e-06',\n", + "{'AccelerationVoltage': '300000',\n", + " 'AcquisitionDatetime': '2026-07-02T11:26:48.0789374-07:00',\n", + " 'AcquisitionStartDatetime': '2026-07-02T18:26:48.1623132Z',\n", + " 'AcquisitionUnit': 'Pixel',\n", + " 'Alpha': '0',\n", " 'ApplicationSoftware': 'AutoScript TEM',\n", - " 'ApplicationSoftwareVersion': '1.15.0.484',\n", - " 'AzimuthAngle': '0.785398163',\n", - " 'AzimuthAngle_145': '2.35619449',\n", - " 'AzimuthAngle_157': '3.92699082',\n", - " 'AzimuthAngle_169': '5.49778714',\n", - " 'BeamConvergence': '0.0299979344',\n", + " 'ApplicationSoftwareVersion': '1.17.0.342',\n", + " 'BeamCurrent': '4e-09',\n", " 'BeamDiameter': '0',\n", - " 'Begin': '0',\n", - " 'Begin_118': '0',\n", - " 'Begin_126': '0.0728785469',\n", - " 'C1LensIntensity': '-0.451997418',\n", - " 'C2LensIntensity': '0.194438682',\n", - " 'C3LensIntensity': '0.352046547',\n", - " 'CameraLength': '0.091',\n", - " 'CollectionAngle': '0.7',\n", - " 'CollectionAngle_146': '0.7',\n", - " 'CollectionAngle_158': '0.7',\n", - " 'CollectionAngle_170': '0.7',\n", - " 'ComputerName': 'TITAN52340180',\n", - " 'ControlSoftwareVersion': '3.21.1',\n", - " 'DarkGainCorrectionType': 'DarkGain',\n", - " 'DarkGainCorrectionType_195': 'DarkGain',\n", - " 'DarkGainCorrectionType_206': 'DarkGain',\n", - " 'Defocus': '-2.8e-08',\n", + " 'BeamType': 'Electron',\n", + " 'Beta': '0',\n", + " 'CameraLength': '0',\n", + " 'CompositionType': 'Single',\n", + " 'ComputerName': 'UPRATIUSH-T14G6',\n", + " 'Defocus': '0',\n", " 'Detector': 'HAADF',\n", - " 'DetectorIndex': '5',\n", - " 'DetectorName': 'BF-S',\n", - " 'DetectorName_112': 'DF-S',\n", - " 'DetectorName_120': 'HAADF',\n", - " 'DetectorName_128': 'SuperXG21',\n", - " 'DetectorName_140': 'SuperXG22',\n", - " 'DetectorName_152': 'SuperXG23',\n", - " 'DetectorName_164': 'SuperXG24',\n", - " 'DetectorName_176': 'BM-Ceta',\n", - " 'DetectorName_186': 'EF-CCD',\n", - " 'DetectorName_196': 'Flucam',\n", + " 'DetectorName': 'HAADF',\n", " 'DetectorType': 'ScanningDetector',\n", - " 'DetectorType_113': 'ScanningDetector',\n", - " 'DetectorType_121': 'ScanningDetector',\n", - " 'DetectorType_129': 'AnalyticalDetector',\n", - " 'DetectorType_141': 'AnalyticalDetector',\n", - " 'DetectorType_153': 'AnalyticalDetector',\n", - " 'DetectorType_165': 'AnalyticalDetector',\n", - " 'DetectorType_177': 'ImagingDetector',\n", - " 'DetectorType_187': 'ImagingDetector',\n", - " 'DetectorType_197': 'ImagingDetector',\n", - " 'Diameter': '0.002',\n", - " 'Diameter_24': '7e-05',\n", - " 'Diameter_30': '0.002',\n", - " 'Diameter_36': '0',\n", - " 'Diameter_42': '0',\n", - " 'DiffractionLensIntensity': '0.191390786',\n", - " 'Dispersion': '5',\n", - " 'Dispersion_147': '5',\n", - " 'Dispersion_159': '5',\n", - " 'Dispersion_171': '5',\n", " 'DwellTime': '1e-06',\n", " 'EFTEMOn': 'false',\n", - " 'ElectronicsNoise': '25.36',\n", - " 'ElectronicsNoise_151': '25.17',\n", - " 'ElectronicsNoise_163': '24.35',\n", - " 'ElectronicsNoise_175': '25.46',\n", - " 'ElevationAngle': '0.31415927',\n", - " 'ElevationAngle_144': '0.31415927',\n", - " 'ElevationAngle_156': '0.31415927',\n", - " 'ElevationAngle_168': '0.31415927',\n", - " 'Enabled': 'true',\n", - " 'Enabled_115': 'true',\n", - " 'Enabled_123': 'true',\n", - " 'Enabled_131': 'false',\n", - " 'Enabled_143': 'false',\n", - " 'Enabled_155': 'false',\n", - " 'Enabled_167': 'false',\n", - " 'End': '0',\n", - " 'End_119': '0',\n", - " 'End_127': '0.2',\n", - " 'ExposureTime': '0.5',\n", - " 'ExposureTime_194': '0.5',\n", - " 'ExposureTime_205': '0.0128',\n", - " 'ExtractorVoltage': '3600.03662',\n", - " 'Focus': '-2.8e-05',\n", - " 'FrameTime': '0.398883',\n", - " 'Gain': '31.89951',\n", - " 'Gain_116': '21.75261',\n", - " 'Gain_124': '27.5886537',\n", - " 'Gain_198': '0.7',\n", - " 'Guid': '4bc8b814-c86a-4744-937e-43d94387dfa3',\n", - " 'GunLensSetting': '789.10675',\n", + " 'ExtractorVoltage': '4000',\n", + " 'Focus': '0',\n", + " 'Gamma': '1',\n", + " 'Guid': 'ce5e5d59-dc37-46f4-9818-941acbc1cc60',\n", + " 'GunLensSetting': '0',\n", " 'Height': '512',\n", - " 'Height_183': '4096',\n", - " 'Height_193': '4096',\n", - " 'Height_204': '512',\n", - " 'Height_96': '512',\n", - " 'HighMagnificationMode': 'None',\n", - " 'HolderType': 'SingleTilt',\n", - " 'IlluminationIntensityNormalized': '0.194438682',\n", - " 'IlluminationMode': 'Probe',\n", - " 'Index': '0',\n", - " 'Index_25': '1',\n", - " 'Index_31': '0',\n", - " 'Index_37': '0',\n", - " 'Index_43': '0',\n", - " 'Inserted': 'false',\n", - " 'Inserted_114': 'false',\n", - " 'Inserted_122': 'true',\n", - " 'Inserted_130': 'true',\n", - " 'Inserted_142': 'true',\n", - " 'Inserted_154': 'true',\n", - " 'Inserted_166': 'true',\n", - " 'InstrumentClass': 'Titan',\n", - " 'InstrumentID': '4018',\n", - " 'InstrumentModel': 'Spectra',\n", - " 'IntermediateLensIntensity': '0.0603362652',\n", - " 'LastMeasuredScreenCurrent': '1.79987863e-10',\n", - " 'LineIntegrationCount': '1',\n", - " 'LineInterlacing': '1',\n", - " 'LineTime': '0.000779',\n", - " 'LorentzLensIntensity': '0',\n", - " 'MainsLockOn': 'false',\n", + " 'Height_54': '512',\n", + " 'HolderType': 'DoubleTilt',\n", + " 'IlluminationIntensityNormalized': '50',\n", + " 'InstrumentID': '12345',\n", + " 'InstrumentModel': 'Fake_Talos',\n", + " 'IntensityOffset': '0',\n", + " 'IntensityScale': '1',\n", " 'Manufacturer': 'FEI Company',\n", - " 'MechanismType': 'Motorized',\n", - " 'MechanismType_22': 'Motorized',\n", - " 'MechanismType_28': 'Motorized',\n", - " 'MechanismType_34': 'Motorized',\n", - " 'MechanismType_40': 'Motorized',\n", - " 'MiniCondenserLensIntensity': '0.343435886',\n", - " 'Name': 'C1',\n", - " 'Name_21': 'C2',\n", - " 'Name_27': 'C3',\n", - " 'Name_33': 'OBJ',\n", - " 'Name_39': 'SA',\n", - " 'NominalMagnification': '226274.17',\n", - " 'Number': '1',\n", - " 'Number_20': '2',\n", - " 'Number_26': '3',\n", - " 'Number_32': '4',\n", - " 'Number_38': '5',\n", - " 'ObjectiveLensIntensity': '0.823946244',\n", + " 'NominalMagnification': '58000',\n", " 'ObjectiveLensMode': 'HM',\n", - " 'Offset': '0',\n", - " 'OffsetEnergy': '-250',\n", - " 'OffsetEnergy_150': '-250',\n", - " 'OffsetEnergy_162': '-250',\n", - " 'OffsetEnergy_174': '-250',\n", - " 'Offset_117': '0',\n", - " 'Offset_125': '-1.752',\n", - " 'OperatingMode': 'STEM',\n", - " 'ProbeMode': 'Nanoprobe',\n", - " 'Projector1LensIntensity': '0.2809157',\n", - " 'Projector2LensIntensity': '0.910340794',\n", - " 'ProjectorMode': 'Diffraction',\n", - " 'PulseProcessTime': '3e-06',\n", - " 'PulseProcessTime_148': '3e-06',\n", - " 'PulseProcessTime_160': '3e-06',\n", - " 'PulseProcessTime_172': '3e-06',\n", - " 'STEMFocus': '-2.8e-08',\n", - " 'SampleTiltCorrectionOn': 'false',\n", - " 'ScanRotation': '0',\n", - " 'ScreenCurrent': '1.79987863e-10',\n", - " 'ShutterState': 'Closed',\n", - " 'ShutterState_149': 'Closed',\n", - " 'ShutterState_161': 'Closed',\n", - " 'ShutterState_173': 'Closed',\n", - " 'SourceType': 'XFEG',\n", - " 'SpotIndex': '7',\n", - " 'TEMOperatingSubMode': 'None',\n", - " 'Type': 'Cicular',\n", - " 'Type_23': 'Cicular',\n", - " 'Type_29': 'Cicular',\n", - " 'Type_35': 'None',\n", - " 'Type_41': 'None',\n", + " 'OperatingMode': 'TEM',\n", + " 'ProbeMode': 'Microprobe',\n", + " 'ProjectionChamberPressure': '0',\n", + " 'ProjectorMode': 'Imaging',\n", + " 'STEMFocus': '0',\n", + " 'SampleLoader': 'None',\n", + " 'SamplePressure': '0',\n", + " 'SourceType': 'FEG',\n", + " 'SpotIndex': '1',\n", + " 'TEMOperatingSubMode': 'BrightField',\n", " 'VacuumMode': 'Ready',\n", " 'Width': '512',\n", - " 'Width_182': '4096',\n", - " 'Width_192': '4096',\n", - " 'Width_203': '512',\n", - " 'Width_95': '512',\n", - " 'X': '3.72184104e-07',\n", - " 'X_178': '1',\n", - " 'X_180': '0',\n", - " 'X_188': '1',\n", - " 'X_190': '0',\n", - " 'X_199': '1',\n", - " 'X_201': '256',\n", - " 'X_208': '7.269221e-10',\n", - " 'X_210': '-1.86092058e-07',\n", - " 'X_65': '4.05897982e-18',\n", - " 'X_67': '0',\n", - " 'X_69': '0',\n", - " 'X_85': '1.2722565e-05',\n", - " 'X_93': '0',\n", - " 'Y': '3.72184104e-07',\n", - " 'Y_179': '1',\n", - " 'Y_181': '0',\n", - " 'Y_189': '1',\n", - " 'Y_191': '0',\n", - " 'Y_200': '1',\n", - " 'Y_202': '256',\n", - " 'Y_209': '7.269221e-10',\n", - " 'Y_211': '-1.86092058e-07',\n", - " 'Y_66': '-6.81691992e-18',\n", - " 'Y_68': '0',\n", - " 'Y_70': '0',\n", - " 'Y_86': '-3.1532784e-05',\n", - " 'Y_94': '0',\n", - " 'Z': '-0.00011909739',\n", + " 'Width_53': '512',\n", + " 'X': '0',\n", + " 'X_22': '0',\n", + " 'X_24': '0',\n", + " 'X_26': '0',\n", + " 'X_28': '0',\n", + " 'X_41': '0',\n", + " 'X_51': '0',\n", + " 'X_63': '1e-08',\n", + " 'Y': '0',\n", + " 'Y_23': '0',\n", + " 'Y_25': '0',\n", + " 'Y_27': '0',\n", + " 'Y_29': '0',\n", + " 'Y_42': '0',\n", + " 'Y_52': '0',\n", + " 'Y_64': '1e-08',\n", + " 'Z': '0',\n", " 'acquisition_type': 'stem_image',\n", " 'detector': 'HAADF'}\n", "Image shape: (512, 512)\n", @@ -479,25 +334,25 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "24ffc973", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3a26909bc9ac4b48bdde5d5431554650", + "model_id": "4c94b74e96a34c74b432cfd76d521d19", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -542,25 +397,25 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "990eeeb6", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "adc5143e1328401a92e3becdd5108f68", + "model_id": "364a951db11d484e9410da5b5c94e58b", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -696,7 +551,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.12.13" }, "title": "Image Acquisition" }, diff --git a/notebooks/11_Test_AI_Agent.ipynb b/notebooks/11_Test_AI_Agent.ipynb new file mode 100644 index 0000000..ce806e3 --- /dev/null +++ b/notebooks/11_Test_AI_Agent.ipynb @@ -0,0 +1,335 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a7067841", + "metadata": {}, + "source": [ + "# AI Agent Demo\n", + "\n", + "Minimal LangChain proof of concept that loads tools from the asyncroscopy MCP server and asks the model to use one or two of them. This will be useful to test our MCP server and new tools." + ] + }, + { + "cell_type": "markdown", + "id": "7e557242", + "metadata": {}, + "source": [ + "## Prereqs\n", + "\n", + "Start the Tango stack and MCP server first:\n", + "\n", + "```bash\n", + "uv run startup_scripts/run_servers.py\n", + "uv run startup_scripts/run_mcp.py --yaml configs/mcp.yaml\n", + "```\n", + "\n", + "Install the optional AI extras:\n", + "\n", + "```bash\n", + "uv sync --extra agent\n", + "# for local models do uv sync --extra agent --extra localagent\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "76a9e540", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pprint import pprint\n", + "\n", + "from langchain.agents import create_agent\n", + "from langchain.chat_models import init_chat_model\n", + "from langchain_mcp_adapters.client import MultiServerMCPClient\n", + "from langchain_core.tools import BaseTool" + ] + }, + { + "cell_type": "markdown", + "id": "d98c5fa3", + "metadata": {}, + "source": [ + "### Connect to the running MCP server" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "38070335", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 60 tool(s)\n", + "['get_data_from_key', 'list_devices', 'CAMERA_State', 'CAMERA_Status', 'CORRECTOR_State', 'CORRECTOR_Status', 'CORRECTOR_acquire_tableau', 'CORRECTOR_correct_aberration', 'CORRECTOR_get_aberrations_coeff_sim', 'CORRECTOR_get_info', 'CORRECTOR_measure_c1a1', 'CORRECTOR_reconnect', 'CORRECTOR_set_aberrations_coeff_sim', 'DATA_State', 'DATA_Status', 'DATA_configure', 'DATA_get_config', 'DATA_register_path', 'DATA_register_save_path', 'DATA_start_tiled_server', 'DATA_stop_tiled_server', 'EDS_State', 'EDS_Status', 'FLUCAM_State', 'FLUCAM_Status', 'AutoScriptMicroscope_Connect', 'AutoScriptMicroscope_Disconnect', 'AutoScriptMicroscope_State', 'AutoScriptMicroscope_Status', 'AutoScriptMicroscope_acquire_camera_image', 'AutoScriptMicroscope_acquire_flucam_image', 'AutoScriptMicroscope_acquire_scanned_data_advanced', 'AutoScriptMicroscope_acquire_scanned_image', 'AutoScriptMicroscope_acquire_spectrum', 'AutoScriptMicroscope_auto_focus', 'AutoScriptMicroscope_blank_beam', 'AutoScriptMicroscope_calibrate_screen_current', 'AutoScriptMicroscope_get_beam_tilt', 'AutoScriptMicroscope_get_defocus', 'AutoScriptMicroscope_get_fov', 'AutoScriptMicroscope_get_image_data_cached', 'AutoScriptMicroscope_get_image_shift', 'AutoScriptMicroscope_get_screen_current', 'AutoScriptMicroscope_get_stage', 'AutoScriptMicroscope_get_status', 'AutoScriptMicroscope_move_stage', 'AutoScriptMicroscope_place_beam', 'AutoScriptMicroscope_place_beam_list', 'AutoScriptMicroscope_register_stage', 'AutoScriptMicroscope_set_beam_tilt', 'AutoScriptMicroscope_set_column_valves', 'AutoScriptMicroscope_set_defocus', 'AutoScriptMicroscope_set_fov', 'AutoScriptMicroscope_set_image_shift', 'AutoScriptMicroscope_set_screen_current', 'AutoScriptMicroscope_unblank_beam', 'SCAN_State', 'SCAN_Status', 'STAGE_State', 'STAGE_Status']\n" + ] + } + ], + "source": [ + "MCP_URL = \"http://127.0.0.1:8095/mcp\"\n", + "\n", + "client = MultiServerMCPClient(\n", + " {\n", + " \"asyncroscopy\": {\n", + " \"url\": MCP_URL,\n", + " \"transport\": \"streamable_http\",\n", + " }\n", + " }\n", + ")\n", + "\n", + "tools = await client.get_tools()\n", + "print(f\"Loaded {len(tools)} tool(s)\")\n", + "print([tool.name for tool in tools])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "475a8e82", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtered to 2 tool(s): ['list_devices', 'AutoScriptMicroscope_acquire_scanned_image']\n" + ] + } + ], + "source": [ + "def filter_tools(tools: list[BaseTool], tool_names: list[str]) -> list[BaseTool]:\n", + " return [tool for tool in tools if tool.name in tool_names]\n", + "\n", + "# Filter the tools so we can test a few at a time\n", + "tools = filter_tools(tools, [\"list_devices\", \"AutoScriptMicroscope_acquire_scanned_image\", \"get_data_from_key\"])\n", + "print(f\"Filtered to {len(tools)} tool(s): {[tool.name for tool in tools]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f726c1f", + "metadata": {}, + "source": [ + "### Run cell below to use an OPENAI-COMPATIBLE model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "358a7f9f", + "metadata": {}, + "outputs": [], + "source": [ + "model = init_chat_model(\n", + " model=\"YOUR MODEL NAME\",\n", + " model_provider=\"openai, google_genai, etc.\", # Make sure to install the right provider package for the model you want to use\n", + " api_key=\"YOUR API KEY\", \n", + ")\n", + "\n", + "using_local_model = False" + ] + }, + { + "cell_type": "markdown", + "id": "9697e487", + "metadata": {}, + "source": [ + "### Run cell below to use a LOCAL model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8ed64650", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b8154b9351b14719ab8ab0645d35e77a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading weights: 0%| | 0/1188 [00:00 4: + self.stage_beta = np.degrees(positions[4]) + self.sync_ui_to_vars() + + def current_conditions(self): + starting_stage_position = self.microscope.get_stage() + self.stage_x = starting_stage_position[0]*1e9 + self.stage_y = starting_stage_position[1]*1e9 + self.stage_z = starting_stage_position[2]*1e9 + self.stage_alpha = np.degrees(starting_stage_position[3]) + self.stage_beta = 0 + if len(starting_stage_position)<4 : + if starting_stage_position[4] is not None: + self.stage_beta = np.degrees(starting_stage_position[4]) + self.beam_x, self.beam_y = self.microscope.get_image_shift() + self.df = self.microscope.get_defocus() + self.beam_alpha, self.beam_beta = self.microscope.get_beam_tilt() + + + # --- UI Helpers --- + def create_grid_field(self, parent, text, var, unit, r, c): + tk.Label(parent, text=text, bg="#161616", fg="white", font=("Arial", 9)).grid(row=r, column=c, padx=2, pady=4, sticky="e") + ttk.Entry(parent, textvariable=var, width=7, font=("Consolas", 10)).grid(row=r, column=c+1, padx=2, pady=4) + tk.Label(parent, text=unit, bg="#161616", fg="#777777", font=("Arial", 8)).grid(row=r, column=c+2, padx=2, pady=4, sticky="w") + + def add_step_selector(self, parent, text, var, values, unit, col): + tk.Label(parent, text=text, bg="#222222", fg="#ffffff").grid(row=0, column=col, padx=4, sticky="e") + ttk.Combobox(parent, textvariable=var, values=values, width=6, state="readonly").grid(row=0, column=col+1, padx=2) + tk.Label(parent, text=unit + " |", bg="#222222", fg="#888888").grid(row=0, column=col+2, padx=2, sticky="w") + + def build_dpad(self, parent, up_txt, dn_txt, lt_txt, rt_txt, command_cb, reset_cb): + tk.Button(parent, text=f"🔼 {up_txt}", font=("Arial", 9), width=5, command=lambda: command_cb(0, 1)).grid(row=0, column=1, pady=3, padx=3) + tk.Button(parent, text=f"◀️ {lt_txt}", font=("Arial", 9), width=5, command=lambda: command_cb(-1, 0)).grid(row=1, column=0, pady=3, padx=3) + tk.Button(parent, text="🏠 H", font=("Arial", 9), width=5, bg="#444444", fg="white", command=reset_cb).grid(row=1, column=1, pady=3, padx=3) + tk.Button(parent, text=f"▶️ {rt_txt}", font=("Arial", 9), width=5, command=lambda: command_cb(1, 0)).grid(row=1, column=2, pady=3, padx=3) + tk.Button(parent, text=f"🔽 {dn_txt}", font=("Arial", 9), width=5, command=lambda: command_cb(0, -1)).grid(row=2, column=1, pady=3, padx=3) + + # --- Processing Logic Engine --- + def set_stage(self): + """Move the mechanical stage to the target coordinates.""" + self.microscope.move_stage([self.stage_x*1e-9, self.stage_y*1e-9, self.stage_z*1e-9, + np.radians(self.stage_alpha), np.radians(self.stage_beta)]) + + def set_defocus(self): + """Set the defocus value.""" + self.microscope.set_defocus(self.df * 1e-9) # Convert nm to meters + + def set_beam_shift(self): + """Set the beam shift values.""" + pass + self.microscope.set_image_shift([self.beam_x*1e-9, self.beam_y*1e-9]) # Convert nm to meters + + def set_beam_tilt(self): + """Set the beam tilt values.""" + if self.beam_alpha > 1000.0: + self.beam_alpha = 1000.0 + if self.beam_beta > 1000.0: + self.beam_beta = 1000.0 + self.microscope.set_beam_tilt([self.beam_alpha*1e-3, self.beam_beta*1e-3]) # Convert mrad to actual input value + + def sync_ui_to_vars(self): + move_stage = False + if self.x_var != f"{self.stage_x:.2f}": + move_stage = True + if self.y_var != f"{self.stage_y:.2f}": + move_stage = True + if self.z_var != f"{self.stage_z:.2f}": + move_stage = True + if self.alpha_var != f"{self.stage_alpha:.2f}": + move_stage = True + if self.beta_var != f"{self.stage_beta:.2f}": + move_stage = True + if move_stage: + self.set_stage() + if self.df_var != f"{self.df:.2f}": + self.set_defocus() + if self.bsx_var != f"{self.beam_x:.2f}"or self.bsy_var != f"{self.beam_y:.2f}": + self.set_beam_shift() + if self.btx_var != f"{self.beam_alpha:.2f}" or self.bty_var != f"{self.beam_beta:.2f}": + self.set_beam_tilt() + self.current_conditions() + self.x_var.set(f"{self.stage_x:.2f}"); + self.y_var.set(f"{self.stage_y:.2f}"); + self.z_var.set(f"{self.stage_z:.2f}") + self.alpha_var.set(f"{self.stage_alpha:.2f}"); + self.beta_var.set(f"{self.stage_beta:.2f}") + self.bsx_var.set(f"{self.beam_x:.2f}"); + self.bsy_var.set(f"{self.beam_y:.2f}"); + self.df_var.set(f"{self.df:.2f}") + self.btx_var.set(f"{self.beam_alpha:.2f}"); + self.bty_var.set(f"{self.beam_beta:.2f}") + def fetch_vars_from_ui(self): + self.stage_x, self.stage_y, self.stage_z = float(self.x_var.get()), float(self.y_var.get()), float(self.z_var.get()) + self.stage_alpha, self.stage_beta = float(self.alpha_var.get()), float(self.beta_var.get()) + self.beam_x, self.beam_y, self.df = float(self.bsx_var.get()), float(self.bsy_var.get()), float(self.df_var.get()) + self.beam_alpha, self.beam_beta = float(self.btx_var.get()), float(self.bty_var.get()) + def jog_engine(self, mx=0, my=0, mz=0, ma=0, mb=0, mbsx=0, mbsy=0, mdf=0, mbtx=0, mbty=0): + try: + step_stg_lin = float(self.stg_lin_var.get()) + step_stg_ang = float(self.stg_ang_var.get()) + step_bm_sft = float(self.bm_sft_var.get()) + step_bm_tlt = float(self.bm_tlt_var.get()) + self.stage_x += (mx * step_stg_lin) + self.stage_y += (my * step_stg_lin) + self.stage_z += (mz * step_stg_lin) + self.stage_alpha += (ma * step_stg_ang) + self.stage_beta += (mb * step_stg_ang) + self.beam_x += (mbsx * step_bm_sft) + self.beam_y += (mbsy * step_bm_sft) + self.df += (mdf * step_bm_sft) + self.beam_alpha += (mbtx * step_bm_tlt) + self.beam_beta += (mbty * step_bm_tlt) + self.sync_ui_to_vars() + except ValueError: + messagebox.showerror("Error", "Invalid inputs found. Check entry numeric parameters.") + def go_to_absolute(self): + try: + self.fetch_vars_from_ui() + self.sync_ui_to_vars() + except ValueError: + messagebox.showerror("Error", "Absolute move failed. Check syntax configuration numbers.") + # --- Granular Zero-Reset Implementations --- + def reset_stage_xy(self): + self.stage_x, self.stage_y = 0.0, 0.0 + self.sync_ui_to_vars() + def reset_stage_tilt(self): + self.stage_alpha, self.stage_beta = 0.0, 0.0 + self.sync_ui_to_vars() + def reset_stage_z(self): + self.stage_z = 0.0 + self.sync_ui_to_vars() + def reset_beam_shift(self): + self.beam_x, self.beam_y = 0.0, 0.0 + self.sync_ui_to_vars() + def reset_beam_tilt(self): + self.beam_alpha, self.beam_beta = 0.0, 0.0 + self.sync_ui_to_vars() + def reset_defocus(self): + self.df = 0.0 + self.sync_ui_to_vars() + def reset_all(self): + self.stage_x, self.stage_y, self.stage_z, self.stage_alpha, self.stage_beta = 0.0, 0.0, 0.0, 0.0, 0.0 + self.beam_x, self.beam_y, self.df, self.beam_alpha, self.beam_beta = 0.0, 0.0, 0.0, 0.0, 0.0 + self.sync_ui_to_vars() + + +if __name__ == "__main__": + root = tk.Tk() + app = AdvancedMicroscopeGUI(root) + root.mainloop() diff --git a/pyproject.toml b/pyproject.toml index c82695a..f1d7f14 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,14 +32,17 @@ dependencies = [ # "autoscript-tem-snippets-tests", -> version 1.17 doesnt have this "autoscript-tem-toolkit", "thermoscientific-logging", + # PyJEM / JEOL (local wheel) + "pyjem", "aicspylibczi>=3.3.1", "jupyter-book>=2.0.0", "tiled[all]>=0.2.9", "pyyaml>=6.0.3", - "pyqt5>=5.15.11,<5.16", + "pyqt5>=5.15.11,<5.16; sys_platform != 'darwin' or platform_machine != 'arm64'", "pyqt5-qt5==5.15.2; sys_platform == 'win32'", "pyqt6>=6.8,<6.13", "ipympl>=0.10.0", + "tifffile>=2026.5.15", ] [project.optional-dependencies] @@ -50,6 +53,22 @@ diffraction = [ "ase>=3.27.0", ] +agent = [ + "langchain", + "langchain-openai", + "langgraph", + "langchain-mcp-adapters", +] + +localagent = [ + "accelerate", + "transformers", + "torch>=2.7.0", + "torchvision", + "bitsandbytes", + "langchain-huggingface", +] + [tool.setuptools] package-dir = { "" = "." } @@ -57,7 +76,8 @@ package-dir = { "" = "." } include = ["asyncroscopy*"] [tool.uv.sources] -autoscript-core = { path = "stubs/v_1.17/autoscript_core-1.3.0-py3-none-any.whl" } -autoscript-tem-microscope-client = { path = "stubs/v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl" } -autoscript-tem-toolkit = { path = "stubs/v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl" } -thermoscientific-logging = { path = "stubs/v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl" } +autoscript-core = { path = "stubs/AutoScript_v_1.17/autoscript_core-1.3.0-py3-none-any.whl" } +autoscript-tem-microscope-client = { path = "stubs/AutoScript_v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl" } +autoscript-tem-toolkit = { path = "stubs/AutoScript_v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl" } +thermoscientific-logging = { path = "stubs/AutoScript_v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl" } +pyjem = { path = "stubs/PyJEM_v_1.3.0.3564/PyJEM-1.3.0.3564-py3-none-any.whl" } diff --git a/stubs/autoscript_core-1.0.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/autoscript_core-1.0.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/autoscript_core-1.0.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/autoscript_core-1.0.0-py3-none-any.whl diff --git a/stubs/autoscript_tem_microscope_client-1.15.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/autoscript_tem_microscope_client-1.15.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/autoscript_tem_microscope_client-1.15.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/autoscript_tem_microscope_client-1.15.0-py3-none-any.whl diff --git a/stubs/autoscript_tem_microscope_client_tests-1.15.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/autoscript_tem_microscope_client_tests-1.15.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/autoscript_tem_microscope_client_tests-1.15.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/autoscript_tem_microscope_client_tests-1.15.0-py3-none-any.whl diff --git a/stubs/autoscript_tem_snippets_tests-1.15.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/autoscript_tem_snippets_tests-1.15.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/autoscript_tem_snippets_tests-1.15.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/autoscript_tem_snippets_tests-1.15.0-py3-none-any.whl diff --git a/stubs/autoscript_tem_toolkit-1.15.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/autoscript_tem_toolkit-1.15.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/autoscript_tem_toolkit-1.15.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/autoscript_tem_toolkit-1.15.0-py3-none-any.whl diff --git a/stubs/requirements.txt b/stubs/AutoScript_v_1.15/requirements.txt old mode 100755 new mode 100644 similarity index 55% rename from stubs/requirements.txt rename to stubs/AutoScript_v_1.15/requirements.txt index 7c0938c..d94e69b --- a/stubs/requirements.txt +++ b/stubs/AutoScript_v_1.15/requirements.txt @@ -1,21 +1,25 @@ -# In case you have trouble installing Pillow due to the zlib library use: Pillow -C zlib=disable -# When adding a new dependency, don't forget to regenerate environment bundle. (see manual) - ---find-links="." - -pillow -numpy -matplotlib -colorama -opencv_python -lxml -defusedxml -h5py -pytest -pyside6 -autoscript_core -autoscript_tem_microscope_client -autoscript_tem_microscope_client_tests -autoscript_tem_toolkit -autoscript_tem_snippets_tests +# LEGACY (AutoScript 1.15 bundle). The canonical install is `uv sync` from the +# repo root, which resolves vendor wheels via [tool.uv.sources] in pyproject.toml. +# This pip path is kept only for the self-contained 1.15 wheels in this folder +# (run pip from within this directory so --find-links="." finds them). +# In case you have trouble installing Pillow due to the zlib library use: Pillow -C zlib=disable +# When adding a new dependency, don't forget to regenerate environment bundle. (see manual) + +--find-links="." + +pillow +numpy +matplotlib +colorama +opencv_python +lxml +defusedxml +h5py +pytest +pyside6 +autoscript_core +autoscript_tem_microscope_client +autoscript_tem_microscope_client_tests +autoscript_tem_toolkit +autoscript_tem_snippets_tests thermoscientific_logging \ No newline at end of file diff --git a/stubs/thermoscientific_logging-1.0.0-py3-none-any.whl b/stubs/AutoScript_v_1.15/thermoscientific_logging-1.0.0-py3-none-any.whl old mode 100755 new mode 100644 similarity index 100% rename from stubs/thermoscientific_logging-1.0.0-py3-none-any.whl rename to stubs/AutoScript_v_1.15/thermoscientific_logging-1.0.0-py3-none-any.whl diff --git a/stubs/v_1.17/autoscript_core-1.3.0-py3-none-any.whl b/stubs/AutoScript_v_1.17/autoscript_core-1.3.0-py3-none-any.whl similarity index 100% rename from stubs/v_1.17/autoscript_core-1.3.0-py3-none-any.whl rename to stubs/AutoScript_v_1.17/autoscript_core-1.3.0-py3-none-any.whl diff --git a/stubs/v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl b/stubs/AutoScript_v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl similarity index 100% rename from stubs/v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl rename to stubs/AutoScript_v_1.17/autoscript_tem_microscope_client-1.17.0-py3-none-any.whl diff --git a/stubs/v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl b/stubs/AutoScript_v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl similarity index 100% rename from stubs/v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl rename to stubs/AutoScript_v_1.17/autoscript_tem_toolkit-1.17.0-py3-none-any.whl diff --git a/stubs/v_1.17/released-notes/AutoScript TEM Release Notes - 309374.pdf b/stubs/AutoScript_v_1.17/released-notes/AutoScript TEM Release Notes - 309374.pdf similarity index 100% rename from stubs/v_1.17/released-notes/AutoScript TEM Release Notes - 309374.pdf rename to stubs/AutoScript_v_1.17/released-notes/AutoScript TEM Release Notes - 309374.pdf diff --git a/stubs/v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl b/stubs/AutoScript_v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl similarity index 100% rename from stubs/v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl rename to stubs/AutoScript_v_1.17/thermoscientific_logging-1.3.0-py3-none-any.whl diff --git a/stubs/PyJEM_v_1.3.0.3564/PyJEM-1.3.0.3564-py3-none-any.whl b/stubs/PyJEM_v_1.3.0.3564/PyJEM-1.3.0.3564-py3-none-any.whl new file mode 100644 index 0000000..1cbf15d Binary files /dev/null and b/stubs/PyJEM_v_1.3.0.3564/PyJEM-1.3.0.3564-py3-none-any.whl differ diff --git a/stubs/acknowledgement.md b/stubs/acknowledgement.md index c3a9f1e..dfa0dee 100644 --- a/stubs/acknowledgement.md +++ b/stubs/acknowledgement.md @@ -1 +1,3 @@ -Acknowledgment: The wheels in this repository were built using the free trial version of Thermo Fisher AutoScript TEM Software. \ No newline at end of file +Acknowledgment: The wheels in this repository were built using the free trial version of Thermo Fisher AutoScript TEM Software. + +Acknowledgment: The PyJEM wheel (`stubs/PyJEM_v_1.3.0.3564/`) is the JEOL PyJEM package, credited to JEOL Ltd. It is repackaged here as a local uv wheel (`PyJEM-uv`) for reproducible installs; the API and copyright belong to JEOL. \ No newline at end of file diff --git a/tests/conftest.py b/tests/conftest.py index b3d1706..da8065d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -197,7 +197,7 @@ def patched_single_image(monkeypatch: pytest.MonkeyPatch) -> None: Patch AutoScriptMicroscope._acquire_scanned_image so acquire_scanned_image() works without AutoScript/hardware. """ - def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0]): + def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], output_format: str = ".h5"): # Deterministic image makes tests stable arr = np.arange(imsize * imsize, dtype=np.uint16) return FakeAdornedImage(arr.reshape(imsize, imsize)) @@ -218,7 +218,7 @@ def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["h def patched_path_acquisition(monkeypatch: pytest.MonkeyPatch, tmp_path): calls = [] - def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0]): + def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], output_format: str = ".h5"): calls.append( { "imsize": imsize, @@ -239,7 +239,7 @@ def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["h def patched_scanned_path_acquisition(monkeypatch: pytest.MonkeyPatch, tmp_path): calls = [] - def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0]): + def fake_acquire(self, imsize: int, dwell_time: float, detector_list: list = ["haadf"], scan_region: list[float] = [0.0, 0.0, 1.0, 1.0], output_format: str = ".h5"): calls.append( { "imsize": imsize, diff --git a/tests/test_data_device.py b/tests/test_data_device.py index 579b044..f6622a9 100644 --- a/tests/test_data_device.py +++ b/tests/test_data_device.py @@ -134,12 +134,12 @@ def fake_popen(command, **kwargs): def test_catalog_database_uri_uses_sqlite_uri_for_windows_drive_path(self) -> None: assert ( - _catalog_database_uri("C:/Users/ahoust17/Desktop/18167694/.asyncroscopy_tiled_catalog.db") - == "sqlite:///C:/Users/ahoust17/Desktop/18167694/.asyncroscopy_tiled_catalog.db" + _catalog_database_uri("C:/tiled_catalog_test/.asyncroscopy_tiled_catalog.db") + == "sqlite:///C:/tiled_catalog_test/.asyncroscopy_tiled_catalog.db" ) assert ( - _catalog_database_uri("C:\\Users\\ahoust17\\Desktop\\18167694\\.asyncroscopy_tiled_catalog.db") - == "sqlite:///C:/Users/ahoust17/Desktop/18167694/.asyncroscopy_tiled_catalog.db" + _catalog_database_uri("C:\\tiled_catalog_test\\.asyncroscopy_tiled_catalog.db") + == "sqlite:///C:/tiled_catalog_test/.asyncroscopy_tiled_catalog.db" ) def test_start_tiled_server_uses_sqlite_uri_for_windows_catalog( @@ -178,15 +178,20 @@ def kill(self): or type("Result", (), {"returncode": 0, "stdout": ""})() ), ) + # The Windows drive path below is fed only to exercise the + # drive-path -> sqlite-URI branch; neutralize the mkdir side effect so + # the test does not depend on the path being creatable (a non-admin user + # cannot create directories under C:\, and the path can't exist on Linux). + monkeypatch.setattr("asyncroscopy.data.data._ensure_directory", lambda path: None) data_proxy.host = "127.0.0.1" data_proxy.port = 9091 - data_proxy.save_path = "C:/Users/ahoust17/Desktop/18167694" + data_proxy.save_path = "C:/tiled_catalog_test" calls.clear() returned = json.loads(data_proxy.start_tiled_server()) - expected_catalog = "sqlite:///C:/Users/ahoust17/Desktop/18167694/.asyncroscopy_tiled_catalog.db" + expected_catalog = "sqlite:///C:/tiled_catalog_test/.asyncroscopy_tiled_catalog.db" assert returned["tiled_server"] == "yes" assert run_commands[0][6] == expected_catalog assert popen_calls[0][5] == expected_catalog diff --git a/tests/test_data_writer.py b/tests/test_data_writer.py index 3644370..4253fcf 100644 --- a/tests/test_data_writer.py +++ b/tests/test_data_writer.py @@ -1,8 +1,11 @@ +import json import types import h5py import numpy as np +import tifffile + from asyncroscopy.data.data_writer import save_acquisition, save_acquisition_hdf5 @@ -40,6 +43,32 @@ def test_save_acquisition_hdf5_writes_data_and_xml_leaf_attrs(tmp_path): assert h5["images/HAADF"].attrs["detector"] == "HAADF" +def test_dict_dataset_attrs_are_written_as_attrs(tmp_path): + data_server = FakeDataServer(tmp_path) + # PyJEM returns raw pixels plus a get_detectorsetting()-style dict separately; + # the dict is handed to save_acquisition via dataset_attrs and should land as + # HDF5 attrs alongside the standard ones. + metadata = { + "ExposureTimeValue": 1000.0, + "GainIndex": 5, + "ImagingArea": {"X": 0, "Y": 0, "Width": 512, "Height": 512}, + } + image = np.arange(4, dtype=np.uint16).reshape(2, 2) + + path = save_acquisition(object(), data_server, "stem_image", ["HAADF"], [image], dataset_attrs=[metadata]) + + with h5py.File(path, "r") as h5: + dset = h5["image/HAADF"] + assert dset[()].tolist() == [[0, 1], [2, 3]] + assert dset.attrs["ExposureTimeValue"] == 1000.0 + assert dset.attrs["GainIndex"] == 5 + # nested dict values are json-encoded, like other non-scalar attrs + assert json.loads(dset.attrs["ImagingArea"]) == metadata["ImagingArea"] + # the standard attrs are still written alongside the detector metadata + assert dset.attrs["acquisition_type"] == "stem_image" + assert dset.attrs["detector"] == "HAADF" + + def test_save_acquisition_writes_scanned_images_as_ordered_image_detector_datasets(tmp_path): data_server = FakeDataServer(tmp_path) detectors = ["HAADF", "BF-S", "DF-S"] @@ -53,3 +82,21 @@ def test_save_acquisition_writes_scanned_images_as_ordered_image_detector_datase for index, detector in enumerate(detectors): assert h5[f"image/{detector}"][()].tolist() == images[index].tolist() assert h5[f"image/{detector}"].attrs["detector"] == detector + + +def test_save_acquisition_tiff_writes_one_registered_file_per_detector(tmp_path): + data_server = FakeDataServer(tmp_path) + detectors = ["HAADF", "BF-S"] + images = [np.full((2, 2), index, dtype=np.int16) for index in range(len(detectors))] + # JEOL passes a get_detectorsetting()-style dict per detector; it should be + # json-encoded into each TIFF's ImageDescription (nested dicts included). + attrs = [{"GainIndex": index, "ImagingArea": {"Width": 512}} for index in range(len(detectors))] + + stem = save_acquisition(object(), data_server, "stem_image", detectors, images, dataset_attrs=attrs, output_format=".tiff") + + for index, detector in enumerate(detectors): + path = tmp_path / f"{stem}_{detector}.tiff" + assert path.exists() + assert np.array_equal(tifffile.imread(path), images[index]) + with tifffile.TiffFile(path) as tif: + assert json.loads(tif.pages[0].description) == attrs[index] diff --git a/tests/test_jeol_microscope.py b/tests/test_jeol_microscope.py new file mode 100644 index 0000000..d0ac204 --- /dev/null +++ b/tests/test_jeol_microscope.py @@ -0,0 +1,24 @@ +import numpy as np + +from asyncroscopy.instruments.electron_microscope.jeol import JeolMicroscope + + +class TestDecodeRawdata: + def test_decodes_bytes_into_2d_int16_image(self) -> None: + # PyJEM's snapshot_rawdata() returns a raw little-endian int16 byte buffer, + # not an array — the decoder must turn it into a 2D image. + original = np.arange(6, dtype=np.dtype(' None: + original = (np.arange(512 * 512, dtype=np.dtype('