using for loop to install conda package
This commit is contained in:
753
.CondaPkg/env/Lib/site-packages/imageio/plugins/spe.py
vendored
Normal file
753
.CondaPkg/env/Lib/site-packages/imageio/plugins/spe.py
vendored
Normal file
@@ -0,0 +1,753 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# imageio is distributed under the terms of the (new) BSD License.
|
||||
|
||||
""" Read SPE files.
|
||||
|
||||
Backend: internal
|
||||
|
||||
This plugin supports reading files saved in the Princeton Instruments
|
||||
SPE file format.
|
||||
|
||||
Parameters for reading
|
||||
----------------------
|
||||
char_encoding : str
|
||||
Character encoding used to decode strings in the metadata. Defaults
|
||||
to "latin1".
|
||||
check_filesize : bool
|
||||
The number of frames in the file is stored in the file header. However,
|
||||
this number may be wrong for certain software. If this is `True`
|
||||
(default), derive the number of frames also from the file size and
|
||||
raise a warning if the two values do not match.
|
||||
sdt_meta : bool
|
||||
If set to `True` (default), check for special metadata written by the
|
||||
`SDT-control` software. Does not have an effect for files written by
|
||||
other software.
|
||||
|
||||
Metadata for reading
|
||||
--------------------
|
||||
ROIs : list of dict
|
||||
Regions of interest used for recording images. Each dict has the
|
||||
"top_left" key containing x and y coordinates of the top left corner,
|
||||
the "bottom_right" key with x and y coordinates of the bottom right
|
||||
corner, and the "bin" key with number of binned pixels in x and y
|
||||
directions.
|
||||
comments : list of str
|
||||
The SPE format allows for 5 comment strings of 80 characters each.
|
||||
controller_version : int
|
||||
Hardware version
|
||||
logic_output : int
|
||||
Definition of output BNC
|
||||
amp_hi_cap_low_noise : int
|
||||
Amp switching mode
|
||||
mode : int
|
||||
Timing mode
|
||||
exp_sec : float
|
||||
Alternative exposure in seconds
|
||||
date : str
|
||||
Date string
|
||||
detector_temp : float
|
||||
Detector temperature
|
||||
detector_type : int
|
||||
CCD / diode array type
|
||||
st_diode : int
|
||||
Trigger diode
|
||||
delay_time : float
|
||||
Used with async mode
|
||||
shutter_control : int
|
||||
Normal, disabled open, or disabled closed
|
||||
absorb_live : bool
|
||||
on / off
|
||||
absorb_mode : int
|
||||
Reference strip or file
|
||||
can_do_virtual_chip : bool
|
||||
True or False whether chip can do virtual chip
|
||||
threshold_min_live : bool
|
||||
on / off
|
||||
threshold_min_val : float
|
||||
Threshold minimum value
|
||||
threshold_max_live : bool
|
||||
on / off
|
||||
threshold_max_val : float
|
||||
Threshold maximum value
|
||||
time_local : str
|
||||
Experiment local time
|
||||
time_utc : str
|
||||
Experiment UTC time
|
||||
adc_offset : int
|
||||
ADC offset
|
||||
adc_rate : int
|
||||
ADC rate
|
||||
adc_type : int
|
||||
ADC type
|
||||
adc_resolution : int
|
||||
ADC resolution
|
||||
adc_bit_adjust : int
|
||||
ADC bit adjust
|
||||
gain : int
|
||||
gain
|
||||
sw_version : str
|
||||
Version of software which created this file
|
||||
spare_4 : bytes
|
||||
Reserved space
|
||||
readout_time : float
|
||||
Experiment readout time
|
||||
type : str
|
||||
Controller type
|
||||
clockspeed_us : float
|
||||
Vertical clock speed in microseconds
|
||||
readout_mode : ["full frame", "frame transfer", "kinetics", ""]
|
||||
Readout mode. Empty string means that this was not set by the
|
||||
Software.
|
||||
window_size : int
|
||||
Window size for Kinetics mode
|
||||
file_header_ver : float
|
||||
File header version
|
||||
chip_size : [int, int]
|
||||
x and y dimensions of the camera chip
|
||||
virt_chip_size : [int, int]
|
||||
Virtual chip x and y dimensions
|
||||
pre_pixels : [int, int]
|
||||
Pre pixels in x and y dimensions
|
||||
post_pixels : [int, int],
|
||||
Post pixels in x and y dimensions
|
||||
geometric : list of {"rotate", "reverse", "flip"}
|
||||
Geometric operations
|
||||
sdt_major_version : int
|
||||
(only for files created by SDT-control)
|
||||
Major version of SDT-control software
|
||||
sdt_minor_version : int
|
||||
(only for files created by SDT-control)
|
||||
Minor version of SDT-control software
|
||||
sdt_controller_name : str
|
||||
(only for files created by SDT-control)
|
||||
Controller name
|
||||
exposure_time : float
|
||||
(only for files created by SDT-control)
|
||||
Exposure time in seconds
|
||||
color_code : str
|
||||
(only for files created by SDT-control)
|
||||
Color channels used
|
||||
detection_channels : int
|
||||
(only for files created by SDT-control)
|
||||
Number of channels
|
||||
background_subtraction : bool
|
||||
(only for files created by SDT-control)
|
||||
Whether background subtraction war turned on
|
||||
em_active : bool
|
||||
(only for files created by SDT-control)
|
||||
Whether EM was turned on
|
||||
em_gain : int
|
||||
(only for files created by SDT-control)
|
||||
EM gain
|
||||
modulation_active : bool
|
||||
(only for files created by SDT-control)
|
||||
Whether laser modulation (“attenuate”) was turned on
|
||||
pixel_size : float
|
||||
(only for files created by SDT-control)
|
||||
Camera pixel size
|
||||
sequence_type : str
|
||||
(only for files created by SDT-control)
|
||||
Type of sequnce (standard, TOCCSL, arbitrary, …)
|
||||
grid : float
|
||||
(only for files created by SDT-control)
|
||||
Sequence time unit (“grid size”) in seconds
|
||||
n_macro : int
|
||||
(only for files created by SDT-control)
|
||||
Number of macro loops
|
||||
delay_macro : float
|
||||
(only for files created by SDT-control)
|
||||
Time between macro loops in seconds
|
||||
n_mini : int
|
||||
(only for files created by SDT-control)
|
||||
Number of mini loops
|
||||
delay_mini : float
|
||||
(only for files created by SDT-control)
|
||||
Time between mini loops in seconds
|
||||
n_micro : int (only for files created by SDT-control)
|
||||
Number of micro loops
|
||||
delay_micro : float (only for files created by SDT-control)
|
||||
Time between micro loops in seconds
|
||||
n_subpics : int
|
||||
(only for files created by SDT-control)
|
||||
Number of sub-pictures
|
||||
delay_shutter : float
|
||||
(only for files created by SDT-control)
|
||||
Camera shutter delay in seconds
|
||||
delay_prebleach : float
|
||||
(only for files created by SDT-control)
|
||||
Pre-bleach delay in seconds
|
||||
bleach_time : float
|
||||
(only for files created by SDT-control)
|
||||
Bleaching time in seconds
|
||||
recovery_time : float
|
||||
(only for files created by SDT-control)
|
||||
Recovery time in seconds
|
||||
comment : str
|
||||
(only for files created by SDT-control)
|
||||
User-entered comment. This replaces the "comments" field.
|
||||
datetime : datetime.datetime
|
||||
(only for files created by SDT-control)
|
||||
Combines the "date" and "time_local" keys. The latter two plus
|
||||
"time_utc" are removed.
|
||||
modulation_script : str
|
||||
(only for files created by SDT-control)
|
||||
Laser modulation script. Replaces the "spare_4" key.
|
||||
|
||||
"""
|
||||
|
||||
from datetime import datetime
|
||||
import logging
|
||||
import os
|
||||
from typing import Any, Callable, Dict, Mapping, Optional, Sequence, Union
|
||||
|
||||
import numpy as np
|
||||
|
||||
from ..core import Format
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Spec:
|
||||
"""SPE file specification data
|
||||
|
||||
Tuples of (offset, datatype, count), where offset is the offset in the SPE
|
||||
file and datatype is the datatype as used in `numpy.fromfile`()
|
||||
|
||||
`data_start` is the offset of actual image data.
|
||||
|
||||
`dtypes` translates SPE datatypes (0...4) to numpy ones, e. g. dtypes[0]
|
||||
is dtype("<f") (which is np.float32).
|
||||
|
||||
`controllers` maps the `type` metadata to a human readable name
|
||||
|
||||
`readout_modes` maps the `readoutMode` metadata to something human readable
|
||||
although this may not be accurate since there is next to no documentation
|
||||
to be found.
|
||||
"""
|
||||
|
||||
basic = {
|
||||
"datatype": (108, "<h"), # dtypes
|
||||
"xdim": (42, "<H"),
|
||||
"ydim": (656, "<H"),
|
||||
"xml_footer_offset": (678, "<Q"),
|
||||
"NumFrames": (1446, "<i"),
|
||||
"file_header_ver": (1992, "<f"),
|
||||
}
|
||||
|
||||
metadata = {
|
||||
# ROI information
|
||||
"NumROI": (1510, "<h"),
|
||||
"ROIs": (
|
||||
1512,
|
||||
np.dtype(
|
||||
[
|
||||
("startx", "<H"),
|
||||
("endx", "<H"),
|
||||
("groupx", "<H"),
|
||||
("starty", "<H"),
|
||||
("endy", "<H"),
|
||||
("groupy", "<H"),
|
||||
]
|
||||
),
|
||||
10,
|
||||
),
|
||||
# chip-related sizes
|
||||
"xDimDet": (6, "<H"),
|
||||
"yDimDet": (18, "<H"),
|
||||
"VChipXdim": (14, "<h"),
|
||||
"VChipYdim": (16, "<h"),
|
||||
# other stuff
|
||||
"controller_version": (0, "<h"),
|
||||
"logic_output": (2, "<h"),
|
||||
"amp_high_cap_low_noise": (4, "<H"), # enum?
|
||||
"mode": (8, "<h"), # enum?
|
||||
"exposure_sec": (10, "<f"),
|
||||
"date": (20, "<10S"),
|
||||
"detector_temp": (36, "<f"),
|
||||
"detector_type": (40, "<h"),
|
||||
"st_diode": (44, "<h"),
|
||||
"delay_time": (46, "<f"),
|
||||
# shutter_control: normal, disabled open, disabled closed
|
||||
# But which one is which?
|
||||
"shutter_control": (50, "<H"),
|
||||
"absorb_live": (52, "<h"),
|
||||
"absorb_mode": (54, "<H"),
|
||||
"can_do_virtual_chip": (56, "<h"),
|
||||
"threshold_min_live": (58, "<h"),
|
||||
"threshold_min_val": (60, "<f"),
|
||||
"threshold_max_live": (64, "<h"),
|
||||
"threshold_max_val": (66, "<f"),
|
||||
"time_local": (172, "<7S"),
|
||||
"time_utc": (179, "<7S"),
|
||||
"adc_offset": (188, "<H"),
|
||||
"adc_rate": (190, "<H"),
|
||||
"adc_type": (192, "<H"),
|
||||
"adc_resolution": (194, "<H"),
|
||||
"adc_bit_adjust": (196, "<H"),
|
||||
"gain": (198, "<H"),
|
||||
"comments": (200, "<80S", 5),
|
||||
"geometric": (600, "<H"), # flags
|
||||
"sw_version": (688, "<16S"),
|
||||
"spare_4": (742, "<436S"),
|
||||
"XPrePixels": (98, "<h"),
|
||||
"XPostPixels": (100, "<h"),
|
||||
"YPrePixels": (102, "<h"),
|
||||
"YPostPixels": (104, "<h"),
|
||||
"readout_time": (672, "<f"),
|
||||
"xml_footer_offset": (678, "<Q"),
|
||||
"type": (704, "<h"), # controllers
|
||||
"clockspeed_us": (1428, "<f"),
|
||||
"readout_mode": (1480, "<H"), # readout_modes
|
||||
"window_size": (1482, "<H"),
|
||||
"file_header_ver": (1992, "<f"),
|
||||
}
|
||||
|
||||
data_start = 4100
|
||||
|
||||
dtypes = {
|
||||
0: np.dtype(np.float32),
|
||||
1: np.dtype(np.int32),
|
||||
2: np.dtype(np.int16),
|
||||
3: np.dtype(np.uint16),
|
||||
8: np.dtype(np.uint32),
|
||||
}
|
||||
|
||||
controllers = [
|
||||
"new120 (Type II)",
|
||||
"old120 (Type I)",
|
||||
"ST130",
|
||||
"ST121",
|
||||
"ST138",
|
||||
"DC131 (PentaMax)",
|
||||
"ST133 (MicroMax/Roper)",
|
||||
"ST135 (GPIB)",
|
||||
"VTCCD",
|
||||
"ST116 (GPIB)",
|
||||
"OMA3 (GPIB)",
|
||||
"OMA4",
|
||||
]
|
||||
|
||||
# This was gathered from random places on the internet and own experiments
|
||||
# with the camera. May not be accurate.
|
||||
readout_modes = ["full frame", "frame transfer", "kinetics"]
|
||||
|
||||
# Do not decode the following metadata keys into strings, but leave them
|
||||
# as byte arrays
|
||||
no_decode = ["spare_4"]
|
||||
|
||||
|
||||
class SDTControlSpec:
|
||||
"""Extract metadata written by the SDT-control software
|
||||
|
||||
Some of it is encoded in the comment strings
|
||||
(see :py:meth:`parse_comments`). Also, date and time are encoded in a
|
||||
peculiar way (see :py:meth:`get_datetime`). Use :py:meth:`extract_metadata`
|
||||
to update the metadata dict.
|
||||
"""
|
||||
|
||||
months = {
|
||||
# Convert SDT-control month strings to month numbers
|
||||
"Jän": 1,
|
||||
"Jan": 1,
|
||||
"Feb": 2,
|
||||
"Mär": 3,
|
||||
"Mar": 3,
|
||||
"Apr": 4,
|
||||
"Mai": 5,
|
||||
"May": 5,
|
||||
"Jun": 6,
|
||||
"Jul": 7,
|
||||
"Aug": 8,
|
||||
"Sep": 9,
|
||||
"Okt": 10,
|
||||
"Oct": 10,
|
||||
"Nov": 11,
|
||||
"Dez": 12,
|
||||
"Dec": 12,
|
||||
}
|
||||
|
||||
sequence_types = {
|
||||
# TODO: complete
|
||||
"SEQU": "standard",
|
||||
"SETO": "TOCCSL",
|
||||
"KINE": "kinetics",
|
||||
"SEAR": "arbitrary",
|
||||
}
|
||||
|
||||
class CommentDesc:
|
||||
"""Describe how to extract a metadata entry from a comment string"""
|
||||
|
||||
n: int
|
||||
"""Which of the 5 SPE comment fields to use."""
|
||||
slice: slice
|
||||
"""Which characters from the `n`-th comment to use."""
|
||||
cvt: Callable[[str], Any]
|
||||
"""How to convert characters to something useful."""
|
||||
scale: Union[None, float]
|
||||
"""Optional scaling factor for numbers"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
n: int,
|
||||
slice: slice,
|
||||
cvt: Callable[[str], Any] = str,
|
||||
scale: Optional[float] = None,
|
||||
):
|
||||
self.n = n
|
||||
self.slice = slice
|
||||
self.cvt = cvt
|
||||
self.scale = scale
|
||||
|
||||
comments = {
|
||||
"sdt_major_version": CommentDesc(4, slice(66, 68), int),
|
||||
"sdt_minor_version": CommentDesc(4, slice(68, 70), int),
|
||||
"sdt_controller_name": CommentDesc(4, slice(0, 6), str),
|
||||
"exposure_time": CommentDesc(1, slice(64, 73), float, 10**-6),
|
||||
"color_code": CommentDesc(4, slice(10, 14), str),
|
||||
"detection_channels": CommentDesc(4, slice(15, 16), int),
|
||||
"background_subtraction": CommentDesc(4, 14, lambda x: x == "B"),
|
||||
"em_active": CommentDesc(4, 32, lambda x: x == "E"),
|
||||
"em_gain": CommentDesc(4, slice(28, 32), int),
|
||||
"modulation_active": CommentDesc(4, 33, lambda x: x == "A"),
|
||||
"pixel_size": CommentDesc(4, slice(25, 28), float, 0.1),
|
||||
"sequence_type": CommentDesc(
|
||||
4, slice(6, 10), lambda x: __class__.sequence_types[x]
|
||||
),
|
||||
"grid": CommentDesc(4, slice(16, 25), float, 10**-6),
|
||||
"n_macro": CommentDesc(1, slice(0, 4), int),
|
||||
"delay_macro": CommentDesc(1, slice(10, 19), float, 10**-3),
|
||||
"n_mini": CommentDesc(1, slice(4, 7), int),
|
||||
"delay_mini": CommentDesc(1, slice(19, 28), float, 10**-6),
|
||||
"n_micro": CommentDesc(1, slice(7, 10), int),
|
||||
"delay_micro": CommentDesc(1, slice(28, 37), float, 10**-6),
|
||||
"n_subpics": CommentDesc(1, slice(7, 10), int),
|
||||
"delay_shutter": CommentDesc(1, slice(73, 79), float, 10**-6),
|
||||
"delay_prebleach": CommentDesc(1, slice(37, 46), float, 10**-6),
|
||||
"bleach_time": CommentDesc(1, slice(46, 55), float, 10**-6),
|
||||
"recovery_time": CommentDesc(1, slice(55, 64), float, 10**-6),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def parse_comments(comments: Sequence[str]) -> Union[Dict, None]:
|
||||
"""Extract SDT-control metadata from comments
|
||||
|
||||
Parameters
|
||||
----------
|
||||
comments
|
||||
List of SPE file comments, typically ``metadata["comments"]``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
If SDT-control comments were detected, return a dict of metadata, else
|
||||
`None`.
|
||||
"""
|
||||
sdt_md = {}
|
||||
if comments[4][70:] != "COMVER0500":
|
||||
logger.debug("SDT-control comments not found.")
|
||||
return None
|
||||
|
||||
sdt_md = {}
|
||||
for name, spec in SDTControlSpec.comments.items():
|
||||
try:
|
||||
v = spec.cvt(comments[spec.n][spec.slice])
|
||||
if spec.scale is not None:
|
||||
v *= spec.scale
|
||||
except Exception as e:
|
||||
logger.debug(
|
||||
"Failed to decode SDT-control metadata " f'field "{name}": {e}'
|
||||
)
|
||||
sdt_md[name] = v
|
||||
comment = comments[0] + comments[2]
|
||||
sdt_md["comment"] = comment.strip()
|
||||
return sdt_md
|
||||
|
||||
@staticmethod
|
||||
def get_datetime(date: str, time: str) -> Union[datetime, None]:
|
||||
"""Turn date and time saved by SDT-control into proper datetime object
|
||||
|
||||
Parameters
|
||||
----------
|
||||
date
|
||||
SPE file date, typically ``metadata["date"]``.
|
||||
time
|
||||
SPE file date, typically ``metadata["time_local"]``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
File's datetime if parsing was succsessful, else None.
|
||||
"""
|
||||
try:
|
||||
month = __class__.months[date[2:5]]
|
||||
return datetime(
|
||||
int(date[5:9]),
|
||||
month,
|
||||
int(date[0:2]),
|
||||
int(time[0:2]),
|
||||
int(time[2:4]),
|
||||
int(time[4:6]),
|
||||
)
|
||||
except Exception as e:
|
||||
logger.info(f"Failed to decode date from SDT-control metadata: {e}.")
|
||||
|
||||
@staticmethod
|
||||
def extract_metadata(meta: Mapping, char_encoding: str = "latin1"):
|
||||
"""Extract SDT-control metadata from SPE metadata
|
||||
|
||||
SDT-control stores some metadata in comments and other fields.
|
||||
Extract them and remove unused entries.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
meta
|
||||
SPE file metadata. Modified in place.
|
||||
char_encoding
|
||||
Character encoding used to decode strings in the metadata.
|
||||
"""
|
||||
sdt_meta = __class__.parse_comments(meta["comments"])
|
||||
if not sdt_meta:
|
||||
return
|
||||
# This file has SDT-control metadata
|
||||
meta.pop("comments")
|
||||
meta.update(sdt_meta)
|
||||
|
||||
# Get date and time in a usable format
|
||||
dt = __class__.get_datetime(meta["date"], meta["time_local"])
|
||||
if dt:
|
||||
meta["datetime"] = dt
|
||||
meta.pop("date")
|
||||
meta.pop("time_local")
|
||||
|
||||
sp4 = meta["spare_4"]
|
||||
try:
|
||||
meta["modulation_script"] = sp4.decode(char_encoding)
|
||||
meta.pop("spare_4")
|
||||
except UnicodeDecodeError:
|
||||
logger.warning(
|
||||
"Failed to decode SDT-control laser "
|
||||
"modulation script. Bad char_encoding?"
|
||||
)
|
||||
|
||||
# Get rid of unused data
|
||||
meta.pop("time_utc")
|
||||
meta.pop("exposure_sec")
|
||||
|
||||
|
||||
class SpeFormat(Format):
|
||||
"""See :mod:`imageio.plugins.spe`"""
|
||||
|
||||
def _can_read(self, request):
|
||||
return request.extension in self.extensions
|
||||
|
||||
def _can_write(self, request):
|
||||
return False
|
||||
|
||||
class Reader(Format.Reader):
|
||||
def _open(self, char_encoding="latin1", check_filesize=True, sdt_meta=True):
|
||||
self._file = self.request.get_file()
|
||||
self._char_encoding = char_encoding
|
||||
|
||||
info = self._parse_header(Spec.basic)
|
||||
self._file_header_ver = info["file_header_ver"]
|
||||
self._dtype = Spec.dtypes[info["datatype"]]
|
||||
self._shape = (info["ydim"], info["xdim"])
|
||||
self._len = info["NumFrames"]
|
||||
self._sdt_meta = sdt_meta
|
||||
|
||||
if check_filesize:
|
||||
# Some software writes incorrect `NumFrames` metadata.
|
||||
# To determine the number of frames, check the size of the data
|
||||
# segment -- until the end of the file for SPE<3, until the
|
||||
# xml footer for SPE>=3.
|
||||
data_end = (
|
||||
info["xml_footer_offset"]
|
||||
if info["file_header_ver"] >= 3
|
||||
else os.path.getsize(self.request.get_local_filename())
|
||||
)
|
||||
line = data_end - Spec.data_start
|
||||
line //= self._shape[0] * self._shape[1] * self._dtype.itemsize
|
||||
if line != self._len:
|
||||
logger.warning(
|
||||
"The file header of %s claims there are %s frames, "
|
||||
"but there are actually %s frames.",
|
||||
self.request.filename,
|
||||
self._len,
|
||||
line,
|
||||
)
|
||||
self._len = min(line, self._len)
|
||||
|
||||
self._meta = None
|
||||
|
||||
def _get_meta_data(self, index):
|
||||
if self._meta is None:
|
||||
if self._file_header_ver < 3:
|
||||
self._init_meta_data_pre_v3()
|
||||
else:
|
||||
self._init_meta_data_post_v3()
|
||||
return self._meta
|
||||
|
||||
def _close(self):
|
||||
# The file should be closed by `self.request`
|
||||
pass
|
||||
|
||||
def _init_meta_data_pre_v3(self):
|
||||
self._meta = self._parse_header(Spec.metadata)
|
||||
|
||||
nr = self._meta.pop("NumROI", None)
|
||||
nr = 1 if nr < 1 else nr
|
||||
self._meta["ROIs"] = roi_array_to_dict(self._meta["ROIs"][:nr])
|
||||
|
||||
# chip sizes
|
||||
self._meta["chip_size"] = [
|
||||
self._meta.pop("xDimDet", None),
|
||||
self._meta.pop("yDimDet", None),
|
||||
]
|
||||
self._meta["virt_chip_size"] = [
|
||||
self._meta.pop("VChipXdim", None),
|
||||
self._meta.pop("VChipYdim", None),
|
||||
]
|
||||
self._meta["pre_pixels"] = [
|
||||
self._meta.pop("XPrePixels", None),
|
||||
self._meta.pop("YPrePixels", None),
|
||||
]
|
||||
self._meta["post_pixels"] = [
|
||||
self._meta.pop("XPostPixels", None),
|
||||
self._meta.pop("YPostPixels", None),
|
||||
]
|
||||
|
||||
# comments
|
||||
self._meta["comments"] = [str(c) for c in self._meta["comments"]]
|
||||
|
||||
# geometric operations
|
||||
g = []
|
||||
f = self._meta.pop("geometric", 0)
|
||||
if f & 1:
|
||||
g.append("rotate")
|
||||
if f & 2:
|
||||
g.append("reverse")
|
||||
if f & 4:
|
||||
g.append("flip")
|
||||
self._meta["geometric"] = g
|
||||
|
||||
# Make some additional information more human-readable
|
||||
t = self._meta["type"]
|
||||
if 1 <= t <= len(Spec.controllers):
|
||||
self._meta["type"] = Spec.controllers[t - 1]
|
||||
else:
|
||||
self._meta["type"] = ""
|
||||
m = self._meta["readout_mode"]
|
||||
if 1 <= m <= len(Spec.readout_modes):
|
||||
self._meta["readout_mode"] = Spec.readout_modes[m - 1]
|
||||
else:
|
||||
self._meta["readout_mode"] = ""
|
||||
|
||||
# bools
|
||||
for k in (
|
||||
"absorb_live",
|
||||
"can_do_virtual_chip",
|
||||
"threshold_min_live",
|
||||
"threshold_max_live",
|
||||
):
|
||||
self._meta[k] = bool(self._meta[k])
|
||||
|
||||
# frame shape
|
||||
self._meta["frame_shape"] = self._shape
|
||||
|
||||
# Extract SDT-control metadata if desired
|
||||
if self._sdt_meta:
|
||||
SDTControlSpec.extract_metadata(self._meta, self._char_encoding)
|
||||
|
||||
def _parse_header(self, spec):
|
||||
ret = {}
|
||||
# Decode each string from the numpy array read by np.fromfile
|
||||
decode = np.vectorize(lambda x: x.decode(self._char_encoding))
|
||||
|
||||
for name, sp in spec.items():
|
||||
self._file.seek(sp[0])
|
||||
cnt = 1 if len(sp) < 3 else sp[2]
|
||||
v = np.fromfile(self._file, dtype=sp[1], count=cnt)
|
||||
if v.dtype.kind == "S" and name not in Spec.no_decode:
|
||||
# Silently ignore string decoding failures
|
||||
try:
|
||||
v = decode(v)
|
||||
except Exception:
|
||||
logger.warning(
|
||||
'Failed to decode "{}" metadata '
|
||||
"string. Check `char_encoding` "
|
||||
"parameter.".format(name)
|
||||
)
|
||||
|
||||
try:
|
||||
# For convenience, if the array contains only one single
|
||||
# entry, return this entry itself.
|
||||
v = v.item()
|
||||
except ValueError:
|
||||
v = np.squeeze(v)
|
||||
ret[name] = v
|
||||
return ret
|
||||
|
||||
def _init_meta_data_post_v3(self):
|
||||
info = self._parse_header(Spec.basic)
|
||||
self._file.seek(info["xml_footer_offset"])
|
||||
xml = self._file.read()
|
||||
self._meta = {"__xml": xml}
|
||||
|
||||
def _get_length(self):
|
||||
if self.request.mode[1] in "vV":
|
||||
return 1
|
||||
else:
|
||||
return self._len
|
||||
|
||||
def _get_data(self, index):
|
||||
if index < 0:
|
||||
raise IndexError("Image index %i < 0" % index)
|
||||
if index >= self._len:
|
||||
raise IndexError("Image index %i > %i" % (index, self._len))
|
||||
|
||||
if self.request.mode[1] in "vV":
|
||||
if index != 0:
|
||||
raise IndexError("Index has to be 0 in v and V modes")
|
||||
self._file.seek(Spec.data_start)
|
||||
data = np.fromfile(
|
||||
self._file,
|
||||
dtype=self._dtype,
|
||||
count=self._shape[0] * self._shape[1] * self._len,
|
||||
)
|
||||
data = data.reshape((self._len,) + self._shape)
|
||||
else:
|
||||
self._file.seek(
|
||||
Spec.data_start
|
||||
+ index * self._shape[0] * self._shape[1] * self._dtype.itemsize
|
||||
)
|
||||
data = np.fromfile(
|
||||
self._file, dtype=self._dtype, count=self._shape[0] * self._shape[1]
|
||||
)
|
||||
data = data.reshape(self._shape)
|
||||
return data, self._get_meta_data(index)
|
||||
|
||||
|
||||
def roi_array_to_dict(a):
|
||||
"""Convert the `ROIs` structured arrays to :py:class:`dict`
|
||||
|
||||
Parameters
|
||||
----------
|
||||
a : numpy.ndarray:
|
||||
Structured array containing ROI data
|
||||
|
||||
Returns
|
||||
-------
|
||||
list of dict
|
||||
One dict per ROI. Keys are "top_left", "bottom_right", and "bin",
|
||||
values are tuples whose first element is the x axis value and the
|
||||
second element is the y axis value.
|
||||
"""
|
||||
dict_list = []
|
||||
a = a[["startx", "starty", "endx", "endy", "groupx", "groupy"]]
|
||||
for sx, sy, ex, ey, gx, gy in a:
|
||||
roi_dict = {
|
||||
"top_left": [int(sx), int(sy)],
|
||||
"bottom_right": [int(ex), int(ey)],
|
||||
"bin": [int(gx), int(gy)],
|
||||
}
|
||||
dict_list.append(roi_dict)
|
||||
return dict_list
|
||||
Reference in New Issue
Block a user