nabu 2024.1.0rc3__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/nabu/resources/logger.py

@@ -0,0 +1,130 @@
+import logging
+import logging.config
+
+
+class Logger(object):
+    def __init__(self, loggername, level="DEBUG", logfile="logger.log", console=True):
+        """
+        Configure a Logger object.
+
+        Parameters
+        -----------
+        loggername: str
+            Logger name.
+        level: str, optional
+            Logging level. Can be "debug", "info", "warning", "error", "critical".
+            Default is "debug".
+        logfile: str, optional
+            File where the logs are written.
+            If set to None, the logs are not written in a file.
+            Default is "logger.log".
+        console: bool, optional
+            If set to True, the logs are (also) written in stdout/stderr.
+            Default is True.
+        """
+        self.loggername = loggername
+        self.level = level
+        self.logfile = logfile
+        self.console = console
+        self._configure_logger()
+
+    def _configure_logger(self):
+        conf = self._get_default_config_dict()
+        for handler in conf["handlers"].keys():
+            conf["handlers"][handler]["level"] = self.level.upper()
+        conf["loggers"][self.loggername]["level"] = self.level.upper()
+        if not (self.console):
+            conf["loggers"][self.loggername]["handlers"].remove("console")
+
+        self.config = conf
+        logging.config.dictConfig(conf)
+        self.logger = logging.getLogger(self.loggername)
+
+    def _get_default_config_dict(self):
+        conf = {
+            "version": 1,
+            "formatters": {
+                "default": {"format": "%(asctime)s - %(levelname)s - %(message)s", "datefmt": "%d-%m-%Y %H:%M:%S"},
+                "console": {"format": "%(message)s"},
+            },
+            "handlers": {
+                "console": {
+                    "level": "DEBUG",
+                    "class": "logging.StreamHandler",
+                    "formatter": "console",
+                    "stream": "ext://sys.stdout",
+                },
+                "file": {
+                    "level": "DEBUG",
+                    "class": "logging.FileHandler",
+                    "formatter": "default",
+                    "filename": self.logfile,
+                },
+            },
+            "loggers": {
+                self.loggername: {
+                    "level": "DEBUG",
+                    "handlers": ["console", "file"],
+                    # This logger inherits from root logger - dont propagate !
+                    "propagate": False,
+                }
+            },
+            "disable_existing_loggers": False,
+        }
+        return conf
+
+    def info(self, msg):
+        return self.logger.info(msg)
+
+    def debug(self, msg):
+        return self.logger.debug(msg)
+
+    def warning(self, msg):
+        return self.logger.warning(msg)
+
+    warn = warning
+
+    def error(self, msg):
+        return self.logger.error(msg)
+
+    def fatal(self, msg):
+        return self.logger.fatal(msg)
+
+    def critical(self, msg):
+        return self.logger.critical(msg)
+
+
+def LoggerOrPrint(logger):
+    """
+    Logger that is either a "true" logger object, or a fall-back to "print".
+    """
+    if logger is None:
+        return PrinterLogger()
+    return logger
+
+
+class PrinterLogger(object):
+    def __init__(self):
+        methods = [
+            "debug",
+            "warn",
+            "warning",
+            "info",
+            "error",
+            "fatal",
+            "critical",
+        ]
+        for method in methods:
+            self.__setattr__(method, print)
+
+
+LogLevel = {
+    "notset": logging.NOTSET,
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARN,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+    "fatal": logging.FATAL,
+}

build/lib/nabu/resources/nxflatfield.py

@@ -0,0 +1,217 @@
+import os
+import numpy as np
+from silx.io.url import DataUrl
+from tomoscan.io import HDF5File
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+from ..utils import check_supported, is_writeable
+
+
+def get_frame_possible_urls(dataset_info, user_dir, output_dir, frame_type):
+    """
+    Return a list with the possible location of reduced dark/flat frames.
+
+    Parameters
+    ----------
+    dataset_info: DatasetAnalyzer object
+        DatasetAnalyzer object: data structure containing information on the parsed dataset
+    user_dir: str or None
+        User-provided directory location for the reduced frames.
+    output_dir: str or None
+        Output processing directory
+    frame_type: str
+        Frame type, can be "flats" or "darks".
+    """
+    check_supported(frame_type, ["flats", "darks"], "frame type")
+
+    h5scan = dataset_info.dataset_scanner  # tomoscan object
+    if frame_type == "flats":
+        dataurl_default_template = h5scan.REDUCED_FLATS_DATAURLS[0]
+    else:
+        dataurl_default_template = h5scan.REDUCED_DARKS_DATAURLS[0]
+
+    def make_dataurl(dirname):
+        # The template formatting should be done by tomoscan in principle, but this complicates logging.
+        rel_file_path = dataurl_default_template.file_path().format(
+            scan_prefix=dataset_info.dataset_scanner.get_dataset_basename()
+        )
+        return DataUrl(
+            file_path=os.path.join(dirname, rel_file_path),
+            data_path=dataurl_default_template.data_path(),
+            data_slice=dataurl_default_template.data_slice(),  # not sure if needed
+            scheme="silx",
+        )
+
+    urls = {"user": None, "dataset": None, "output": None}
+
+    if user_dir is not None:
+        urls["user"] = make_dataurl(user_dir)
+
+    # tomoscan.esrf.scan.hdf5scan.REDUCED_{DARKS|FLATS}_DATAURLS.file_path() is a relative path
+    # Create a absolute path instead
+    urls["dataset"] = make_dataurl(os.path.dirname(h5scan.master_file))
+
+    if output_dir is not None:
+        urls["output"] = make_dataurl(output_dir)
+
+    return urls
+
+
+def get_metadata_url(url, frame_type):
+    """
+    Return the url of the metadata stored alongside flats/darks
+    """
+    check_supported(frame_type, ["flats", "darks"], "frame type")
+    template_url = getattr(NXtomoScan, "REDUCED_%s_METADATAURLS" % frame_type.upper())[0]
+    return DataUrl(
+        file_path=url.file_path(),
+        data_path=template_url.data_path(),
+        scheme="silx",
+    )
+
+
+def tomoscan_load_reduced_frames(dataset_info, frame_type, url):
+    tomoscan_method = getattr(dataset_info.dataset_scanner, "load_reduced_%s" % frame_type)
+    return tomoscan_method(
+        inputs_urls=[url],
+        return_as_url=True,
+        return_info=True,
+        metadata_input_urls=[get_metadata_url(url, frame_type)],
+    )
+
+
+def tomoscan_save_reduced_frames(dataset_info, frame_type, url, frames, info):
+    tomoscan_method = getattr(dataset_info.dataset_scanner, "save_reduced_%s" % frame_type)
+    kwargs = {"%s_infos" % frame_type: info, "overwrite": True}
+    return tomoscan_method(
+        frames, output_urls=[url], metadata_output_urls=[get_metadata_url(url, frame_type)], **kwargs
+    )
+
+
+# pylint: disable=E1136
+def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=None, darks_flats_dir=None):
+    """
+    Update a DatasetAnalyzer object with reduced flats/darks (hereafter "reduced frames").
+
+    How the reduced frames are loaded/computed/saved will depend on the "flatfield_mode" parameter.
+
+    The principle is the following:
+    (1) Attempt at loading already-computed reduced frames (XXX_darks.h5 and XXX_flats.h5):
+       - First check files in the user-defined directory 'darks_flats_dir'
+       - Then try to load from files located alongside the .nx dataset (dataset directory)
+       - Then try to load from output_dir, if provided
+    (2) If loading fails, or flatfield_mode == "force_compute", compute the reduced frames.
+    (3) Save these reduced frames
+       - Save in darks_flats_dir, if provided by user
+       - Otherwise, save in the data directory (next to the .nx file), if write access OK
+       - Otherwise, save in output directory
+    """
+    if flatfield_mode is False:
+        return
+    logger = dataset_info.logger
+    frames_types = ["darks", "flats"]
+
+    reduced_frames_urls = {}
+    for frame_type in frames_types:
+        reduced_frames_urls[frame_type] = get_frame_possible_urls(dataset_info, darks_flats_dir, output_dir, frame_type)
+
+    reduced_frames = dict.fromkeys(frames_types, None)
+
+    #
+    # Try to load frames
+    #
+    def load_reduced_frame(url, frame_type, frames_loaded, reduced_frames):
+        if frames_loaded[frame_type]:
+            return
+        frames, info = tomoscan_load_reduced_frames(dataset_info, frame_type, url)
+        if frames not in (None, {}):
+            dataset_info.logger.info("Loaded %s from %s" % (frame_type, url.file_path()))
+            frames_loaded[frame_type] = True
+            reduced_frames[frame_type] = frames, info
+        else:
+            msg = "Could not load %s from %s" % (frame_type, url.file_path())
+            logger.error(msg)
+
+    frames_loaded = dict.fromkeys(frames_types, False)
+    if flatfield_mode != "force-compute":
+        for load_from in ["user", "dataset", "output"]:  # in that order
+            for frame_type in frames_types:
+                url = reduced_frames_urls[frame_type][load_from]
+                if url is None:
+                    continue  # cannot load from this source (eg. undefined folder)
+                load_reduced_frame(url, frame_type, frames_loaded, reduced_frames)
+            if all(frames_loaded.values()):
+                break
+
+    if not all(frames_loaded.values()) and flatfield_mode == "force-load":
+        raise ValueError("Could not load darks/flats (using 'force-load')")
+
+    #
+    # COMPAT. Keep DataUrl - won't be needed in future versions when pipeline will use FlatField
+    # instead of FlatFieldDataUrl
+    frames_urls = reduced_frames.copy()
+    #
+
+    # Compute reduced frames, if needed
+    #
+    if reduced_frames["flats"] is None:
+        reduced_frames["flats"] = dataset_info.dataset_scanner.compute_reduced_flats(return_info=True)
+    if reduced_frames["darks"] is None:
+        reduced_frames["darks"] = dataset_info.dataset_scanner.compute_reduced_darks(return_info=True)
+
+    if reduced_frames["darks"][0] == {} or reduced_frames["flats"][0] == {}:
+        raise ValueError(
+            "Could not get any reduced flat/dark. This probably means that no already-reduced flats/darks were found and that the dataset itself does not have any flat/dark"
+        )
+
+    #
+    # Save reduced frames
+    #
+
+    def save_reduced_frame(url, frame_type, frames_saved):
+        frames, info = reduced_frames[frame_type]
+        tomoscan_save_reduced_frames(dataset_info, frame_type, url, frames, info)
+        dataset_info.logger.info("Saved reduced %s to %s" % (frame_type, url.file_path()))
+        frames_saved[frame_type] = True
+
+    frames_saved = dict.fromkeys(frames_types, False)
+    if not all(frames_loaded.values()):
+        for save_to in ["user", "dataset", "output"]:  # in that order
+            for frame_type in frames_types:
+                if frames_loaded[frame_type]:
+                    continue  # already loaded
+                url = reduced_frames_urls[frame_type][save_to]
+                if url is None:
+                    continue  # cannot load from this source (eg. undefined folder)
+                if not is_writeable(os.path.dirname(url.file_path())):
+                    continue
+                save_reduced_frame(url, frame_type, frames_saved)
+                # COMPAT.
+                if frames_urls[frame_type] is None:
+                    frames_urls[frame_type] = tomoscan_load_reduced_frames(dataset_info, frame_type, url)
+                #
+            if all(frames_saved.values()):
+                break
+
+    dataset_info.flats = frames_urls["flats"][0]  # reduced_frames["flats"] # in future versions
+    dataset_info.flats_srcurrent = frames_urls["flats"][1].machine_electric_current
+    # This is an extra check to avoid having more than 1 (reduced) dark.
+    # FlatField only works with exactly 1 (reduced) dark (having more than 1 series of darks makes little sense)
+    # This is normally prevented by tomoscan HDF5FramesReducer, but let's add this extra check
+    darks_ = frames_urls["darks"][0]  # reduced_frames["darks"] # in future versions
+    if len(darks_) > 1:
+        dark_idx = sorted(darks_.keys())[0]
+        dataset_info.logger.error("Found more that one series of darks. Keeping only the first one")
+        darks_ = {dark_idx: darks_[dark_idx]}
+    #
+    dataset_info.darks = darks_
+    dataset_info.darks_srcurrent = frames_urls["darks"][1].machine_electric_current
+
+
+# tomoscan "compute_reduced_XX" is quite slow. If needed, here is an alternative implementation
+def my_reduce_flats(di):
+    res = {}
+    with HDF5File(di.dataset_hdf5_url.file_path(), "r") as f:
+        for data_slice in di.get_data_slices("flats"):
+            data = f[di.dataset_hdf5_url.data_path()][data_slice.start : data_slice.stop]
+            res[data_slice.start] = np.median(data, axis=0)
+    return res

build/lib/nabu/resources/tests/test_nxflatfield.py

@@ -0,0 +1,104 @@
+from os import path
+from tempfile import mkdtemp
+from shutil import rmtree
+import pytest
+import numpy as np
+from silx.io import get_data
+from nxtomo.nxobject.nxdetector import ImageKey
+from nabu.testutils import generate_nx_dataset
+from nabu.resources.nxflatfield import update_dataset_info_flats_darks
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
+
+
+test_nxflatfield_scenarios = [
+    {
+        "name": "simple",
+        "flats_pos": [slice(1, 6)],
+        "darks_pos": [slice(0, 1)],
+        "output_dir": None,
+    },
+    {
+        "name": "simple_with_save",
+        "flats_pos": [slice(1, 6)],
+        "darks_pos": [slice(0, 1)],
+        "output_dir": None,
+    },
+    {
+        "name": "multiple_with_save",
+        "flats_pos": [slice(0, 10), slice(30, 40)],
+        "darks_pos": [slice(95, 100)],
+        "output_dir": path.join("{tempdir}", "output_reduced"),
+    },
+]
+
+
+# parametrize with fixture and "params=" will launch a new class for each scenario.
+# the attributes set to "cls" will remain for all the tests done in this class
+# with the current scenario.
+@pytest.fixture(scope="class", params=test_nxflatfield_scenarios)
+def bootstrap(request):
+    cls = request.cls
+    cls.n_projs = 265
+    cls.params = request.param
+    cls.tempdir = mkdtemp(prefix="nabu_")
+    yield
+    rmtree(cls.tempdir)
+
+
+@pytest.mark.usefixtures("bootstrap")
+class TestNXFlatField:
+    _reduction_func = {"flats": np.median, "darks": np.mean}
+
+    def get_nx_filename(self):
+        return path.join(self.tempdir, "dataset_" + self.params["name"] + ".nx")
+
+    def get_image_key(self):
+        keys = np.zeros(self.n_projs, np.int32)
+        for what, val in [("flats_pos", ImageKey.FLAT_FIELD.value), ("darks_pos", ImageKey.DARK_FIELD.value)]:
+            for pos in self.params[what]:
+                keys[pos.start : pos.stop] = val
+        return keys
+
+    @staticmethod
+    def check_image_key(dataset_info, frame_type, expected_slices):
+        data_slices = dataset_info.get_data_slices(frame_type)
+        assert set(map(str, data_slices)) == set(map(str, expected_slices))
+
+    def test_nxflatfield(self):
+        dataset_fname = self.get_nx_filename()
+        image_key = self.get_image_key()
+        generate_nx_dataset(dataset_fname, image_key)
+
+        dataset_info = HDF5DatasetAnalyzer(dataset_fname)
+
+        # When parsing a "raw" dataset, flats/darks are a series of images.
+        # dataset_info.flats is a dictionary where each key is the index of the frame.
+        # For example dataset_info.flats.keys() = [10, 11, 12, 13, ..., 19, 1200, 1201, 1202, ..., 1219]
+        for frame_type in ["darks", "flats"]:
+            self.check_image_key(dataset_info, frame_type, self.params[frame_type + "_pos"])
+
+        output_dir = self.params.get("output_dir", None)
+        if output_dir is not None:
+            output_dir = output_dir.format(tempdir=self.tempdir)
+        update_dataset_info_flats_darks(dataset_info, True, output_dir=output_dir)
+        # After reduction (median/mean), the flats/darks are located in another file.
+        # median(series_1) goes to entry/flats/idx1, mean(series_2) goes to entry/flats/idx2, etc.
+        assert set(dataset_info.flats.keys()) == set(s.start for s in self.params["flats_pos"])
+        assert set(dataset_info.darks.keys()) == set(s.start for s in self.params["darks_pos"])
+
+        # Check that the computations were correct
+        # Loads the entire volume in memory ! So keep the data volume small for the tests
+        data_volume = get_data(dataset_info.dataset_hdf5_url)
+        expected_flats = {}
+        for s in self.params["flats_pos"]:
+            expected_flats[s.start] = self._reduction_func["flats"](data_volume[s.start : s.stop], axis=0)
+        expected_darks = {}
+        for s in self.params["darks_pos"]:
+            expected_darks[s.start] = self._reduction_func["darks"](data_volume[s.start : s.stop], axis=0)
+
+        flats = {idx: get_data(dataset_info.flats[idx]) for idx in dataset_info.flats.keys()}
+        for idx in flats.keys():
+            assert np.allclose(flats[idx], expected_flats[idx])
+        darks = {idx: get_data(dataset_info.darks[idx]) for idx in dataset_info.darks.keys()}
+        for idx in darks.keys():
+            assert np.allclose(darks[idx], expected_darks[idx])

build/lib/nabu/resources/tests/test_units.py

@@ -0,0 +1,47 @@
+import pytest
+from nabu.utils import compare_dicts
+from nabu.resources.utils import get_quantities_and_units
+
+
+class TestUnits:
+    expected_results = {
+        "distance = 1 m ; pixel_size = 2.0 um": {"distance": 1.0, "pixel_size": 2e-6},
+        "distance = 1 m ; pixel_size = 2.6 micrometer": {"distance": 1.0, "pixel_size": 2.6e-6},
+        "distance = 10 m ; pixel_size = 2e-6 m": {"distance": 10, "pixel_size": 2e-6},
+        "distance = .5 m ; pixel_size = 2.6e-4 centimeter": {"distance": 0.5, "pixel_size": 2.6e-6},
+        "distance = 10 cm ; pixel_size = 2.5 micrometer ; energy = 1 ev": {
+            "distance": 0.1,
+            "pixel_size": 2.5e-6,
+            "energy": 1.0e-3,
+        },
+        "distance = 10 cm ; pixel_size = 9.0e-3 millimeter ; energy = 19 kev": {
+            "distance": 0.1,
+            "pixel_size": 9e-6,
+            "energy": 19.0,
+        },
+    }
+    expected_failures = {
+        # typo ("ke" instead of "kev")
+        "distance = 10 cm ; energy = 10 ke": ValueError("Cannot convert: ke"),
+        # No units
+        "distance = 10 ; energy = 10 kev": ValueError("not enough values to unpack (expected 2, got 1)"),
+        # Unit not separated by space
+        "distance = 10m; energy = 10 kev": ValueError("not enough values to unpack (expected 2, got 1)"),
+        # Invalid separator
+        "distance = 10 m, energy = 10 kev": ValueError("too many values to unpack (expected 2)"),
+    }
+
+    def test_conversion(self):
+        for test_str, expected_result in self.expected_results.items():
+            res = get_quantities_and_units(test_str)
+            err_msg = str(
+                "Something wrong with quantities/units extraction from '%s': expected %s, got %s"
+                % (test_str, str(expected_result), str(res))
+            )
+            assert compare_dicts(res, expected_result) is None, err_msg
+
+    def test_valid_input(self):
+        for test_str, expected_failure in self.expected_failures.items():
+            with pytest.raises(type(expected_failure)) as e_info:
+                get_quantities_and_units(test_str)
+            assert e_info.value.args[0] == str(expected_failure)

build/lib/nabu/resources/utils.py

@@ -0,0 +1,174 @@
+from ast import literal_eval
+import numpy as np
+from psutil import virtual_memory, cpu_count
+from pyunitsystem.metricsystem import MetricSystem
+from pyunitsystem.energysystem import EnergySI
+
+
+def get_values_from_file(fname, n_values=None, shape=None, sep=None, any_size=False):
+    """
+    Read a text file and scan the values inside.
+    This function expects one value per line, or values separated with a separator
+    defined with the `sep` parameter.
+
+    Parameters
+    ----------
+    fname: str
+        Path of the text file
+    n_values: int, optional
+        If set to a value, this function will check that it scans exactly this
+        number of values.
+        Ignored if `shape` is provided
+    shape: tuple, optional
+        Generalization of n_values for higher dimensions.
+    sep: str, optional
+        Separator between values. Default is white space
+    any_size: bool, optional
+        If set to True, then the parameters 'n_values' and 'shape' are ignored.
+
+    Returns
+    --------
+    arr: numpy.ndarray
+        An array containing the values scanned from the text file
+    """
+    if not (any_size) and not ((n_values is not None) ^ (shape is not None)):
+        raise ValueError("Please provide either n_values or shape")
+    arr = np.loadtxt(fname, ndmin=1)
+    if (n_values is not None) and (arr.shape[0] != n_values):
+        if any_size:
+            arr = arr[:n_values]
+        else:
+            raise ValueError("Expected %d values, but could get %d values" % (n_values, arr.shape[0]))
+    if (shape is not None) and (arr.shape != shape):
+        if any_size:
+            arr = arr[: shape[0], : shape[1]]  # TODO handle more dimensions ?
+        else:
+            raise ValueError("Expected shape %s, but got shape %s" % (shape, arr.shape))
+    return arr
+
+
+def get_memory_per_node(max_mem, is_percentage=True):
+    """
+    Get the available memory per node in GB.
+
+    Parameters
+    ----------
+    max_mem: float
+        If is_percentage is False, then number is interpreted as an absolute
+        number in GigaBytes.
+        Otherwise, it should be a number between 0 and 100 and is interpreted
+        as a percentage.
+    is_percentage: bool
+        A boolean indicating whether the parameter max_mem is to be interpreted
+        as a percentage of available system memory.
+    """
+    sys_avail_mem = virtual_memory().available / 1e9
+    if is_percentage:
+        return (max_mem / 100.0) * sys_avail_mem
+    else:
+        return min(max_mem, sys_avail_mem)
+
+
+def get_threads_per_node(max_threads, is_percentage=True):
+    """
+    Get the available memory per node in GB.
+
+    Parameters
+    ----------
+    max_threads: float
+        If is_percentage is False, then number is interpreted as an absolute
+        number of threads.
+        Otherwise, it should be a number between 0 and 100 and is interpreted
+        as a percentage.
+    is_percentage: bool
+        A boolean indicating whether the parameter max_threads is to be interpreted
+        as a percentage of available system memory.
+    """
+    sys_n_threads = cpu_count(logical=True)
+    if is_percentage:
+        return (max_threads / 100.0) * sys_n_threads
+    else:
+        return min(max_threads, sys_n_threads)
+
+
+def extract_parameters(params_str, sep=";"):
+    """
+    Extract the named parameters from a string.
+
+    Example
+    --------
+    The function can be used as follows:
+
+    >>> extract_parameters("window_width=None; median_filt_shape=(3,3); padding_mode='wrap'")
+    ... {'window_width': None, 'median_filt_shape': (3, 3), 'padding_mode': 'wrap'}
+    """
+    if params_str in ("", None):
+        return {}
+    params_list = params_str.strip(sep).split(sep)
+    res = {}
+    for param_str in params_list:
+        param_name, param_val_str = param_str.strip().split("=")
+        param_name = param_name.strip()
+        param_val_str = param_val_str.strip()
+        param_val = literal_eval(param_val_str)
+        res[param_name] = param_val
+    return res
+
+
+def compact_parameters(params_dict, sep=";"):
+    """
+    Compact the parameters from a dict into a  string.
+
+    This is the inverse of extract_parameters. It can be used for example in tomwer to convert
+    parameters into a string, for example for cor_options, prior to calling a nabu method which
+    is expecting an argument to be in the form of a string containing options.
+
+    Example
+    --------
+    The function can be used as follows:
+
+    >>> compact_parameters( {"side":"near", "near_pos":300 } )
+    ... "side=near; nearpos= 300;"
+    """
+    if params_dict in ({}, None):
+        return ""
+
+    res = ""
+    for key, val in params_dict.items():
+        res = res + "{key} = {val} " + sep
+    return res
+
+
+def is_hdf5_extension(ext):
+    return ext.lower() in ["h5", "hdf5", "nx"]
+
+
+def get_quantities_and_units(string, sep=";"):
+    """
+    Return a dictionary with quantities as keys, and values in SI.
+
+    Example
+    -------
+    get_quantities_and_units("pixel_size = 1.2 um ; distance = 1 m")
+    Will return
+    {"pixel_size": 1.2e-6, "distance": 1}
+    """
+
+    result = {}
+    quantities = string.split(sep)
+    for quantity in quantities:
+        quantity_name, value_and_unit = quantity.split("=")
+        quantity_name = quantity_name.strip()
+        value_and_unit = value_and_unit.strip()
+        value, unit = value_and_unit.split()
+        val = float(value)
+        # Convert to SI
+        try:
+            # handle metrics
+            conversion_factor = MetricSystem.from_str(unit).value
+        except ValueError:
+            # handle energies
+            conversion_factor = EnergySI.from_str(unit).value / EnergySI.KILOELECTRONVOLT.value
+
+        result[quantity_name] = val * conversion_factor
+    return result