def assign_signal_subclass(dtype,
signal_dimension,
signal_type="",
lazy=False):
"""Given record_by and signal_type return the matching Signal subclass.
Parameters
----------
dtype : :class:`~.numpy.dtype`
signal_dimension: int
signal_type : {"EELS", "EDS", "EDS_SEM", "EDS_TEM", "DielectricFunction", "", str}
lazy: bool
Returns
-------
Signal or subclass
"""
import hyperspy.signals
import hyperspy._lazy_signals
from hyperspy.signal import BaseSignal
# Check if parameter values are allowed:
if np.issubdtype(dtype, complex):
dtype = 'complex'
elif ('float' in dtype.name or 'int' in dtype.name or
'void' in dtype.name or 'bool' in dtype.name or
'object' in dtype.name):
dtype = 'real'
else:
raise ValueError('Data type "{}" not understood!'.format(dtype.name))
if not isinstance(signal_dimension, int) or signal_dimension < 0:
raise ValueError("signal_dimension must be a positive interger")
base_signals = find_subclasses(hyperspy.signals, BaseSignal)
lazy_signals = find_subclasses(hyperspy._lazy_signals,
hyperspy._lazy_signals.LazySignal)
if lazy:
signals = lazy_signals
else:
signals = {
k: v for k,
v in base_signals.items() if k not in lazy_signals}
dtype_matches = [s for s in signals.values() if dtype == s._dtype]
dtype_dim_matches = [s for s in dtype_matches
if signal_dimension == s._signal_dimension]
dtype_dim_type_matches = [s for s in dtype_dim_matches if signal_type == s._signal_type
or signal_type in s._alias_signal_types]
if dtype_dim_type_matches:
# Perfect match found, return it.
return dtype_dim_type_matches[0]
elif [s for s in dtype_dim_matches if s._signal_type == ""]:
# just signal_dimension and dtype matches
# Return a general class for the given signal dimension.
return [s for s in dtype_dim_matches if s._signal_type == ""][0]
else:
# no signal_dimension match either, hence return the general subclass for
# correct dtype
return [s for s in dtype_matches if s._signal_dimension == -
1 and s._signal_type == ""][0]
def assign_signal_subclass(dtype,
signal_dimension,
signal_type="",
lazy=False):
"""Given record_by and signal_type return the matching Signal subclass.
Parameters
----------
dtype : :class:`~.numpy.dtype`
signal_dimension: int
signal_type : {"EELS", "EDS", "EDS_SEM", "EDS_TEM", "DielectricFunction", "", str}
lazy: bool
Returns
-------
Signal or subclass
"""
import hyperspy.signals
import hyperspy._lazy_signals
from hyperspy.signal import BaseSignal
# Check if parameter values are allowed:
if np.issubdtype(dtype, complex):
dtype = 'complex'
elif ('float' in dtype.name or 'int' in dtype.name or
'void' in dtype.name or 'bool' in dtype.name or
'object' in dtype.name):
dtype = 'real'
else:
raise ValueError('Data type "{}" not understood!'.format(dtype.name))
if not isinstance(signal_dimension, int) or signal_dimension < 0:
raise ValueError("signal_dimension must be a positive interger")
base_signals = find_subclasses(hyperspy.signals, BaseSignal)
lazy_signals = find_subclasses(hyperspy._lazy_signals,
hyperspy._lazy_signals.LazySignal)
if lazy:
signals = lazy_signals
else:
signals = {
k: v for k,
v in base_signals.items() if k not in lazy_signals}
dtype_matches = [s for s in signals.values() if dtype == s._dtype]
dtype_dim_matches = [s for s in dtype_matches
if signal_dimension == s._signal_dimension]
dtype_dim_type_matches = [s for s in dtype_dim_matches if signal_type == s._signal_type
or signal_type in s._alias_signal_types]
if dtype_dim_type_matches:
# Perfect match found, return it.
return dtype_dim_type_matches[0]
elif [s for s in dtype_dim_matches if s._signal_type == ""]:
# just signal_dimension and dtype matches
# Return a general class for the given signal dimension.
return [s for s in dtype_dim_matches if s._signal_type == ""][0]
else:
# no signal_dimension match either, hence return the general subclass for
# correct dtype
return [s for s in dtype_matches if s._signal_dimension == -
1 and s._signal_type == ""][0]
def assign_signal_subclass(dtype, signal_dimension, signal_type=""):
"""Given record_by and signal_type return the matching Signal subclass.
Parameters
----------
dtype : :class:`~.numpy.dtype`
record_by: {"spectrum", "image", ""}
signal_type : {"EELS", "EDS", "EDS_TEM", "", str}
Returns
-------
Signal or subclass
"""
import hyperspy.signals
from hyperspy.signal import BaseSignal
# Check if parameter values are allowed:
if np.issubdtype(dtype, complex):
dtype = 'complex'
elif ('float' in dtype.name or 'int' in dtype.name or 'void' in dtype.name
or 'bool' in dtype.name):
dtype = 'real'
else:
raise ValueError('Data type "{}" not understood!'.format(dtype.name))
if not isinstance(signal_dimension, int) or signal_dimension < 0:
raise ValueError("signal_dimension must be a positive interger")
signals = hyperspy.misc.utils.find_subclasses(hyperspy.signals, BaseSignal)
dtype_matches = [s for s in signals.values() if dtype == s._dtype]
dtype_dim_matches = [
s for s in dtype_matches if signal_dimension == s._signal_dimension
]
dtype_dim_type_matches = [
s for s in dtype_dim_matches if signal_type == s._signal_type
]
if dtype_dim_type_matches:
# Perfect match found, return it.
return dtype_dim_type_matches[0]
elif [s for s in dtype_dim_matches if s._signal_type == ""]:
# just signal_dimension and dtype matches
# Return a general class for the given signal dimension.
return [s for s in dtype_dim_matches if s._signal_type == ""][0]
else:
# no signal_dimension match either, hence return the general subclass for
# correct dtype
return [
s for s in dtype_matches
if s._signal_dimension == -1 and s._signal_type == ""
][0]
def assign_signal_subclass(dtype,
signal_dimension,
signal_type=""):
"""Given record_by and signal_type return the matching Signal subclass.
Parameters
----------
dtype : :class:`~.numpy.dtype`
record_by: {"spectrum", "image", ""}
signal_type : {"EELS", "EDS", "EDS_TEM", "", str}
Returns
-------
Signal or subclass
"""
import hyperspy.signals
from hyperspy.signal import BaseSignal
# Check if parameter values are allowed:
if np.issubdtype(dtype, complex):
dtype = 'complex'
elif ('float' in dtype.name or 'int' in dtype.name or
'void' in dtype.name or 'bool' in dtype.name):
dtype = 'real'
else:
raise ValueError('Data type "{}" not understood!'.format(dtype.name))
if not isinstance(signal_dimension, int) or signal_dimension < 0:
raise ValueError("signal_dimension must be a positive interger")
signals = hyperspy.misc.utils.find_subclasses(hyperspy.signals, BaseSignal)
dtype_matches = [s for s in signals.values() if dtype == s._dtype]
dtype_dim_matches = [s for s in dtype_matches
if signal_dimension == s._signal_dimension]
dtype_dim_type_matches = [
s for s in dtype_dim_matches if signal_type == s._signal_type]
if dtype_dim_type_matches:
# Perfect match found, return it.
return dtype_dim_type_matches[0]
elif [s for s in dtype_dim_matches if s._signal_type == ""]:
# just signal_dimension and dtype matches
# Return a general class for the given signal dimension.
return [s for s in dtype_dim_matches if s._signal_type == ""][0]
else:
# no signal_dimension match either, hence return the general subclass for
# correct dtype
return [s for s in dtype_matches if s._signal_dimension ==
-1 and s._signal_type == ""][0]
def assign_signal_subclass(record_by="",
signal_type="",
signal_origin="",):
"""Given record_by and signal_type return the matching Signal subclass.
Parameters
----------
record_by: {"spectrum", "image", ""}
signal_type : {"EELS", "EDS", "EDS_TEM", "", str}
signal_origin : {"experiment", "simulation", ""}
Returns
-------
Signal or subclass
"""
import hyperspy.signals
from hyperspy.signal import Signal
if record_by and record_by not in ["image", "spectrum"]:
raise ValueError("record_by must be one of: None, empty string, "
"\"image\" or \"spectrum\"")
if signal_origin and signal_origin not in ["experiment", "simulation"]:
raise ValueError("signal_origin must be one of: None, empty string, "
"\"experiment\" or \"simulation\"")
signals = hyperspy.misc.utils.find_subclasses(hyperspy.signals, Signal)
signals['Signal'] = Signal
if signal_origin == "experiment":
signal_origin = ""
preselection = [s for s in
[s for s in signals.values()
if record_by == s._record_by]
if signal_origin == s._signal_origin]
perfect_match = [s for s in preselection
if signal_type == s._signal_type]
selection = perfect_match[0] if perfect_match else \
[s for s in preselection if s._signal_type == ""][0]
return selection