CompositeCreatorApp#

CompositeCreatorApp with inherited methods#

class pydidas.apps.CompositeCreatorApp(*args, **kwargs)#

Bases: BaseApp

Compose mosaic images of a large number of individual image files.

Parameters can be passed either through the argparse module during command line calls or through keyword arguments in scripts.

The names of the parameters are similar for both cases, only the calling syntax changes slightly, based on the underlying structure used. For the command line, parameters must be passed as -<parameter name> <value>. For keyword arguments, parameters must be passed during instantiation using the standard <parameter name>=<value>.

Notes

Please refer to the help for the full list and explanation of Parameters used by the CompositeCreatorApp.

Parameters:

*args (tuple) – Any number of Parameters. These will be added to the app’s ParameterCollection.
**kwargs (dict) – Parameters supplied with their reference key as dict key and the Parameter itself as value.

add_param(param: Parameter)#

Add a parameter to the ParameterCollection.

This is a wrapper for the ParameterCollection.add_parameter method.

Parameters:: param (Parameter) – An instance of a Parameter object.

add_params(*params: tuple[Parameter | dict | ParameterCollection])#

Add parameters to the object.

This method adds Parameters to the ParameterCollection of the object. Parameters can be either supplies as args or a ParameterCollection or dictionary in the form of <ref_key>: <Parameter>. This method is explicitly separate from the __init__ method to allow subclasses full control over args and kwargs.

Parameters:: *params (Tuple[Union[Parameter, dict, ParameterCollection]]) – Any Parameter or ParameterCollection

apply_thresholds(**kwargs: dict)#

Apply thresholds to the composite image.

This method applies thresholds to the composite image. By default, it will apply the thresholds defined in the ParameterCollection but these can be overwritten with the low and high arguments. Note that these values will be used to update the ParameterCollection. This method will only apply the thresholds to the image but will not return the iamge itself.

Parameters:

low (Union[float, None], optional) – The lower threshold. If not specified, the stored lower threshold from the ParameterCollection will be used. A value of np.nan or None will be ignored.
high (Union[float, None], optional) – The upper threshold. If not specified, the stored upper threshold from the ParameterCollection will be used. A value of np.nan or None will be ignored.

property composite: None | ndarray#

Get the composite image.

Returns:: image – The composite image in np.ndarray format. If no composite has been created, this property returns None.
Return type:: Union[None, np.ndarray]

copy(slave_mode: bool = False) → Self#

Get a copy of the App.

Parameters:: slave_mode (bool, optional) – Keyword to toggle creation of a slave app which does not include attributes marked in the classes slave_mode attribute.
Returns:: App – A copy of the App instance.
Return type:: BaseApp

deepcopy() → Self#

Get a deepcopy of the object.

Returns:: The object’s deepcopy.
Return type:: ObjectWithParameterCollection

export_image(output_fname: str, **kwargs: dict)#

Export the composite image to a file.

This method is a wrapper for the CompositeImageManager.export method. Supported file types for export are all generic datatypes with exporters for 2-dimensional data.

Parameters:

output_fname (str) – The full file system path and filename for the output image file.
**kwargs (dict) –
Additional keyword arguments. Supported arguments are:

data_rangetuple, optional
A tuple with lower and upper bounds for the data export.

export_state() → dict#

Get the sanitized app Parameters and configuration for export.

Returns:: The state dictionary.
Return type:: dict

get_config() → dict#

Get the App configuration.

Returns:: The App configuration stored in the _config dictionary.
Return type:: dict

classmethod get_default_params_copy() → ParameterCollection#

Get a copy of the default ParameterCollection.

Returns:: A copy of the default ParameterCollection.
Return type:: ParameterCollection

get_param(param_key: str) → Parameter#

Get a parameter.

Note: This method returns the Parameter itself, not a copy.

Parameters:: param_key (str) – The key name of the Parameter.
Returns:: The Parameter object.
Return type:: Parameter

get_param_keys() → list[str]#

Get the keys of all registered Parameters.

Returns:: The keys of all registered Parameters.
Return type:: list

get_param_value(param_key: str, *default: object, dtype: type | None = None, for_export: bool = False) → object#

Get a Parameter value.

Parameters:

param_key (str) – The key name of the Parameter.
default (object) – The default value if the param_key does not exist.
dtype (type, optional) – A datatype to convert the value into. If None, the native datatype is returned. The default is None.
for_export (bool, optional) – An optional flag to force converting the Parameter value to an export-compatible format. This flag is not compatible with a specific dtype. The default is False.

Returns:

The value of the Parameter.

Return type:

object

get_param_values_as_dict(filter_types_for_export: bool = False) → dict#

Get a dictionary with Parameter names and values only.

Parameters:: filter_types_for_export (bool) – Flag to return objects in types suitable for exporting (i.e. pickleable).
Returns:: name_val_pairs – The dictionary with Parameter <name>: <value> pairs.
Return type:: dict

get_params(*param_keys: tuple[str, ...]) → list[Parameter]#

Get multiple parameters based on their reference keys.

Parameters:: *param_keys (Tuple[str, ...]) – Any number of reference keys.
Returns:: A list with the Parameter instances referenced by the supplied keys.
Return type:: list

import_state(state: dict)#

Import a stored state including Parameters and configuration.

Parameters:: state (dict) – The stored state.

initialize_shared_memory()#

Initialize the shared memory array for the master app.

Note: This method is not required for apps without a shared memory.

multiprocessing_carryon() → bool#

Get the flag value whether to carry on processing.

By default, this Flag is always True. In the case of live processing, a check is done whether the current file exists.

Returns:: Flag whether the processing can carry on or needs to wait.
Return type:: bool

multiprocessing_func(index: int) → Dataset#

Perform key operation with parallel processing.

Parameters:: index (int) – The image frame index.
Returns:: _image – The (pre-processed) image.
Return type:: pydidas.core.Dataset

multiprocessing_get_tasks() → ndarray#: Return all tasks required in multiprocessing.

multiprocessing_post_run()#: Perform operations after running main parallel processing function.

multiprocessing_pre_cycle(index: int)#

Run preparatory functions in the cycle prior to the main function.

Parameters:: index (int) – The index of the image / frame.

multiprocessing_pre_run()#: Perform operations prior to running main parallel processing function.

multiprocessing_store_results(index: int, image: ndarray)#

Store the results of the multiprocessing operation.

Parameters:

index (int) – The index in the composite image.
image (np.ndarray) – The image data.

property param_keys: list[str]#

Get the keys of all stored Parameters.

Returns:: The keys of all stored Parameters.
Return type:: list[str]

property param_values: dict#

Get the values of all stored Parameters along with their refkeys.

Returns:: The refkey, value pairs for all stored Parameters.
Return type:: Dict

parse_args_and_set_params()#: Parse the command line arguments and update the corresponding Parameter values.

parse_func() → dict#

Parse the command line arguments for the CompositeCreatorApp.

Parameters:: caller (object, optional) – If this function is called by a class as method, it requires a single argument which corresponds to the instance.
Returns:: A dictionary with the parsed arugments which holds all the entries and entered values or - if missing - the default values.
Return type:: dict

prepare_run()#

Prepare running the composite creation.

This method will check all settings and create the composite image or tell the CompositeImage to create a new image with changed size.

Check that filename for the first and last file exist

If first file is hdf5 file: Check that the dataset key exists.

If first file is hdf5 file: Check that the selected image numbers are included in the dataset dimensions.

If first file is not a hdf5 file: Verify that first and last file are in the same directory and that all selected images have the same file size. The file size instead of the actual file content is checked to speed up the process.

Check the ROI settings and assert that the selected dimensions are valid and within the image size.

Check the composite dimensions and assert that the composite image size covers all selected files / images.

If a background subtraction is used, check the background file and assert the image size is the same.

print_param_values()#: Print the name and value of all Parameters.

q_settings_get(key: str, dtype: type | None = None, default: object | None = None) → object#

Get the value from a QSetting key.

Parameters:

key (str) – The QSetting reference key.
dtype (Union[type, None], optional) – A return datatype. If not None, the output will be returned as dtype(value), otherwise, the generic string/int will be returned. The default is None.
default (type, optional) – The default value which is returned if the key defaults to None. The default is None.

Returns:

value – The value, converted to the type associated with the Parameter referenced by param_key or dtype, if given.

Return type:

object

q_settings_set(key: str, value: object)#

Set the value of a QSettings key.

Parameters:

key (str) – The name of the key.
value (object) – The value to be stored.

restore_all_defaults(confirm: bool = False)#

Restore the default values to all entries.

Parameters:: confirm (bool) – Confirmation flag as safety feature.

run()#: Run the app serially without multiprocessing support.

set_default_params()#

Set default entries.

This method will go through the supplied defaults iterable. If there are no entries for the Parameter keys, it will add a Parameter with default value.

set_param_value(param_key: str, value: object)#

Set a parameter value.

Parameters:

param_key (str) – The key name of the Parameter.
value (object) – The value to be set. This has to be the datatype associated with the Parameter.

set_param_values(**kwargs: dict)#

Set multiple parameter values at once.

Parameters:: **kwargs (dict) – The reference key and value pairs for all Parameters to be set.

set_param_values_from_dict(value_dict: dict)#

Set the Parameter values from a dict with name, value paris.

Parameters:: value_dict (dict) – The dictionary with the stored information.

update_param_values_from_kwargs(**kwargs: dict)#

Update the Parameter values corresponding to the given keys.

Parameters:: **kwargs (dict) – The dictionary with Parameter refkeys and values.

update_params_from_init(*args: tuple, **kwargs: dict)#

Update the Parameters from the given init args and kwargs.

Parameters:

*args (Tuple) – The input arguments.
**kwargs (Dict) – The input keyword arguments.