ledsa 0.9.2__py3-none-any.whl

ledsa/__main__.py

@@ -0,0 +1,48 @@
+# this file is executed if the package is run via python -m ledsa [arguments]
+import argparse
+import sys
+from typing import List
+
+from ledsa.core.parser_arguments_declaration import (add_parser_arguments_tools, add_parser_arguments_data_extraction,
+    add_parser_arguments_testing, add_parser_arguments_demo, add_parser_argument_analysis)
+from ledsa.core.parser_arguments_run import run_tools_arguments, run_data_extraction_arguments, run_testing_arguments, run_demo_arguments, \
+    run_analysis_arguments, run_analysis_arguments_with_extinction_coefficient
+
+
+def main(argv: List[str]) -> None:
+    """
+    Main function to execute the LEDSA package with command line arguments.
+
+    :param argv: Command line arguments.
+    :type argv: list[str]
+    """
+    parser = argparse.ArgumentParser(description=
+                                     'Allows the analysis of light dampening of LEDs behind a smoke screen.')
+    add_parser_arguments_tools(parser)
+    add_parser_arguments_data_extraction(parser)
+    add_parser_argument_analysis(parser)
+    add_parser_arguments_demo(parser)
+    add_parser_arguments_testing(parser)
+
+    args = parser.parse_args(argv)
+
+    print('ledsa runs with the following arguments:')
+    print(args)
+
+    if len(argv) == 0:
+        print('Please run with an argument. --help for possible arguments.')
+        exit(0)
+
+    if args.demo:
+        run_demo_arguments(args, parser)
+    else:
+        run_tools_arguments(args)
+        run_data_extraction_arguments(args)
+        run_analysis_arguments(args)
+        run_analysis_arguments_with_extinction_coefficient(args)
+        run_testing_arguments(args)
+
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

ledsa/analysis/ConfigDataAnalysis.py

@@ -0,0 +1,163 @@
+import configparser as cp
+
+
+class ConfigDataAnalysis(cp.ConfigParser):
+    """
+    Class responsible for handling the configuration data related to LEDSA's data analysis.
+
+    """
+    def __init__(self, load_config_file=True, camera_position=None, num_layers=20, domain_bounds=None,
+                 led_array_indices=None, num_ref_images=10, camera_channels=0, num_cores=1,
+                 reference_property='sum_col_val',
+                 average_images=False, solver='linear', weighting_preference=-6e-3, weighting_curvature=1e-6,
+                 num_iterations=200, lambda_reg=1e-3):
+        """
+        :param load_config_file: Determines whether to load the config file on initialization. Defaults to True.
+        :type load_config_file: bool
+        :param camera_position: Global X, Y, Z position of the camera. Defaults to None.
+        :type camera_position: list[float] or None
+        :param num_layers: Number of horizontal smoke layers. Defaults to 20.
+        :type num_layers: int
+        :param domain_bounds: Lower and upper bounds of the computational domain. Defaults to None.
+        :type domain_bounds: list[float] or None
+        :param led_array_indices: Indices of the LED arrays for which the extinction coefficients should be computed. Defaults to None.
+        :type led_array_indices: list[int] or None
+        :param num_ref_images: Number of images used to compute normalize LED intensities. Defaults to 10.
+        :type num_ref_images: int
+        :param camera_channels: Camera channels to be considered in the analysis. Defaults to 0.
+        :type camera_channels: List[int]
+        :param num_cores: Number of CPU cores for (multicore) processing. If greater than 1, multicore processing is applied. Defaults to 1.
+        :type num_cores: int
+        :param reference_property: Property used for reference in LEDSA. Defaults to 'sum_col_val'.
+        :type reference_property: str
+        :param average_images: Determines if intensities are computed as an average from two consecutive images. Defaults to False.
+        :type average_images: bool
+        :param solver: Method used to compute extinction coefficients - can be 'linear' or 'nonlinear'. Defaults to 'linear'.
+        :type solver: str
+        :param weighting_preference: Weighting factor for the preference to push the nonlinear solver to high or low values for the extinction coeffiientes. Defaults to -6e-3.
+        :type weighting_preference: float
+        :param weighting_curvature:  Weighting factor for the smoothness of the solution. Defaults to 1e-6.
+        :type weighting_curvature: float
+        :param num_iterations: Maximum number of iterations for the nonlinear solver. Defaults to 200.
+        :type num_iterations: int
+        :param lambda_reg: Regularization parameter for the linear solver. Defaults to 1e-3.
+        :type lambda_reg: float
+        """
+        cp.ConfigParser.__init__(self, allow_no_value=True)
+        if load_config_file:
+            self.load()
+        else:
+            self['DEFAULT'] = {}
+            self.set('DEFAULT', '# Variables used in multiple parts of LEDSA')
+            self.set('DEFAULT', '   # Number of CPUs, multicore processing is applied if > 1')
+            self['DEFAULT']['   num_cores'] = str(num_cores)
+            self['DEFAULT']['   reference_property'] = str(reference_property)
+            self.set('DEFAULT', '   # Number images used to compute normalize LED intensities')
+            self['DEFAULT']['   num_ref_images'] = str(num_ref_images)
+            self['DEFAULT']['   camera_channels'] = str(camera_channels)
+            self.set('DEFAULT', '   # Intensities are computed as average from two consecutive images if set to True ')
+            self['DEFAULT']['   average_images'] = str(average_images)
+            self.set('DEFAULT', '   # Extinction coefficients can be computed by linear or numeric solver ')
+            self['DEFAULT']['   solver'] = str(solver)
+            self.set('DEFAULT', '   # Options for nonlinear solver (ignored when linear solver is used) ')
+            self['DEFAULT']['   weighting_preference'] = str(weighting_preference)
+            self['DEFAULT']['   weighting_curvature'] = str(weighting_curvature)
+            self['DEFAULT']['   num_iterations'] = str(num_iterations)
+            self.set('DEFAULT', '   # Options for linear solver (ignored when nonlinear solver is used) ')
+            self['DEFAULT']['   lambda_reg'] = str(lambda_reg)
+
+            self['experiment_geometry'] = {}
+            self.set('experiment_geometry', '# Global X Y Z position of the camera ')
+            self['experiment_geometry']['   camera_position'] = str(camera_position)
+
+            self['model_parameters'] = {}
+            self.set('model_parameters', '# Parameters regarding the discretization of the spatial domain ')
+            self.set('model_parameters', '   # LED arrays for that the extinction coefficients should be computed  ')
+            self['model_parameters']['   led_array_indices'] = str(led_array_indices)
+            self.set('model_parameters', '   # Number of horizontal smoke layers  ')
+            self['model_parameters']['   num_layers'] = str(num_layers)
+            self.set('model_parameters', '   # Lower and upper bounds of the computational domain  ')
+            self['model_parameters']['   domain_bounds'] = str(domain_bounds)
+
+            with open('config_analysis.ini', 'w') as configfile:
+                self.write(configfile)
+            print('config_analysis.ini created')
+
+    def load(self) -> None:
+        """
+        Loads the configuration data from 'config_analysis.ini' file.
+
+        Raises:
+            FileNotFoundError: If 'config_analysis.ini' is not found in the working directory.
+        """
+        try:
+            self.read_file(open('config_analysis.ini'))
+        except FileNotFoundError:
+            print(
+                'config_analysis.ini not found in working directory! Please create it with argument "--config_analysis".')
+            exit(1)
+        print('config_analysis.ini loaded!')
+
+    def save(self) -> None:
+        """
+        Saves the current configuration to 'config_analysis.ini' file.
+        """
+        with open('config_analysis.ini', 'w') as configfile:
+            self.write(configfile)
+        print('config_analysis.ini saved')
+
+    def get_list_of_values(self, section:str, option:str, dtype=int) -> None:
+        """
+        Returns a list of values of a specified dtype from a given section and option.
+
+        :param section: Section in the configuration file.
+        :type section: str
+        :param option: Option under the specified section.
+        :type option: str
+        :param dtype: Data type of the values to be returned. Defaults to int.
+        :type dtype: type
+        :return: List of values or None if the option's value is 'None'.
+        :rtype: list or None
+        """
+        if self[section][option] == 'None':
+            return None
+        values = [dtype(i) for i in self[section][option].split()]
+        return values
+
+    def in_camera_channels(self) -> None:
+        """
+        Prompts the user to input the camera channels to analyse and updates the configuration.
+        """
+        self['DEFAULT']['camera_channels'] = input('Please give the camera channels that should be considered in the '
+                                                   'analysis: ')
+
+    def in_camera_position(self) -> None:
+        """
+        Prompts the user to input the camera's global X, Y, Z coordinates and updates the configuration.
+        """
+        self['experiment_geometry']['camera_position'] = input('Please give the global X Y Z [m] coordinates of the '
+                                                               'camera : ')
+
+    def in_num_layers(self) -> None:
+        """
+        Prompts the user to input the number of layers for spatial domain discretization and updates the configuration.
+        """
+        self['model_parameters']['num_layers'] = input('Please give number of layers the spatial domain should '
+                                                          'be discretized to : ')
+
+    def in_domain_bounds(self) -> None:
+        """
+        Prompts the user to input the lower and upper height of the spatial domain and updates the configuration.
+        """
+        self['model_parameters']['domain_bounds'] = input('Please give lower and upper height [m] of the spatial '
+                                                          'domain : ')
+
+    def in_led_array_indices(self) -> None:
+        """
+        Prompts the user to input the indices of (merged) LED Arrays for computation and updates the configuration.
+        """
+        self['model_parameters']['led_array_indices'] = input('Please give indices of (merged) LED Arrays to compute: ')
+
+
+if __name__ == 'main':
+    ConfigDataAnalysis()

ledsa/analysis/Experiment.py

@@ -0,0 +1,313 @@
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List
+
+import numpy as np
+
+
+@dataclass
+class Layer:
+    """
+    Represents a spatial layer with a bottom and top border.
+
+    :ivar bottom_border: The z-coordinate of the bottom border of the layer
+    :vartype bottom_border: float
+    :ivar top_border: The z-coordinate of the top border of the layer
+    :vartype top_border: float
+    """
+    bottom_border: float
+    top_border: float
+
+    def __contains__(self, obj):
+        """
+        Check if a given object's z-coordinate falls within this layer.
+
+        :param obj: The object to check
+        :type obj: object with attribute 'pos_z'
+        :return: True if object is contained within the layer, False otherwise
+        :rtype: bool
+        """
+        if self.bottom_border <= obj.pos_z < self.top_border:
+            return True
+        return False
+
+
+@dataclass
+class Layers:
+    """
+    Represents a collection of spatial layers.
+
+    :ivar amount: The number of layers
+    :vartype amount: int
+    :ivar bottom_border: The z-coordinate of the bottom-most border of the layers
+    :vartype bottom_border: float
+    :ivar top_border: The z-coordinate of the top-most border of the layers
+    :vartype top_border: float
+    """
+    amount: int
+    bottom_border: float
+    top_border: float
+    layers: [Layer] = field(init=False)
+    borders: np.ndarray = field(init=False)
+
+    def __post_init__(self):
+        self.layers = []
+        self.borders = np.linspace(self.bottom_border, self.top_border, self.amount + 1)
+        for i in range(self.amount):
+            self.layers.append(Layer(self.borders[i], self.borders[i + 1]))
+
+    def __getitem__(self, layer):
+        return self.layers[layer]
+
+    def __str__(self):
+        return f'num_of_layers: {self.amount}, bottom_border: {self.bottom_border}, top_border: {self.top_border}\n'
+
+    def __repr__(self):
+        return f'Layers(amount={self.amount}, bottom_border={self.bottom_border}, top_border={self.top_border})'
+
+
+@dataclass
+class Camera:
+    """
+    Contains a camera's position in 3D space.
+
+    :ivar pos_x: The x-coordinate of the camera
+    :vartype pos_x: float
+    :ivar pos_y: The y-coordinate of the camera
+    :vartype pos_y: float
+    :ivar pos_z: The z-coordinate of the camera
+    :vartype pos_z: float
+    """
+    pos_x: float
+    pos_y: float
+    pos_z: float
+
+    def __str__(self):
+        return f'Camera: ({self.pos_x}, {self.pos_y}, {self.pos_z})\n'
+
+    def __repr__(self):
+        return f'Camera(pos_x={self.pos_x}, pos_y={self.pos_y}, pos_z={self.pos_z})'
+
+
+@dataclass
+class LED:
+    """
+    Represents a LED light source in 3D space.
+
+    :ivar id: The identifier for the LED
+    :vartype id: int
+    :ivar pos_x: The x-coordinate of the LED
+    :vartype pos_x: float
+    :ivar pos_y: The y-coordinate of the LED
+    :vartype pos_y: float
+    :ivar pos_z: The z-coordinate of the LED
+    :vartype pos_z: float
+    """
+    id: int
+    pos_x: float
+    pos_y: float
+    pos_z: float
+
+
+class Experiment:
+    """
+    Represents an experimental setup involving layers, an LED array, and a camera.
+
+    :ivar layers: The spatial layers involved in the experiment.
+    :vartype layers: Layers
+    :ivar led_array: The identifier for the LED array.
+    :vartype led_array: int
+    :ivar camera: The camera involved in the experiment.
+    :vartype camera: Camera
+    :ivar leds: List of LED light sources.
+    :vartype leds: List[LED]
+    :ivar led_number: Number of LEDs on LED array.
+    :vartype led_number: int
+    :ivar path: File path for experiment data.
+    :vartype path: Path
+    :ivar channel: The camera channel to be analysed.
+    :vartype channel: int
+    :ivar merge_led_arrays: Whether to merge LED arrays.
+    :vartype merge_led_arrays: bool
+    """
+    def __init__(self, layers: Layers, led_array: int, camera: Camera, path=Path('.'), channel=0,
+                 merge_led_arrays=False):
+        """
+        :param layers: The spatial layers involved in the experiment.
+        :type layers: Layers
+        :param led_array: The identifier for the LED array.
+        :type led_array: int
+        :param camera: The camera involved in the experiment.
+        :type camera: Camera
+        :param path: The file path for experiment data, defaults to current directory.
+        :type path: Path, optional
+        :param channel: The camera channel to be analysed, defaults to 0.
+        :type channel: int, optional
+        :param merge_led_arrays: Whether to merge LED arrays, defaults to False.
+        :type merge_led_arrays: bool, optional
+        """
+        self.num_leds = None
+        self.layers = layers
+        self.led_array = led_array
+        self.camera = camera
+        self.leds = []
+        self.path = path
+        self.channel = channel
+        self.merge_led_arrays = merge_led_arrays
+
+        try:
+            self.set_leds()
+        except IOError as err:
+            print(err)
+
+    def __str__(self):
+        out = f'channel: {self.channel}, led_array: {self.led_array}\n' + \
+              str(self.layers) + \
+              str(self.camera)
+        return out
+
+    def calc_traversed_dist_per_layer(self, led: LED) -> np.ndarray:
+        """
+        Calculate the distance traversed by light from an LED through each layer to the camera.
+
+        :param led: The LED light source
+        :type led: LED
+        :return: Array of distances traversed in each layer
+        :rtype: np.ndarray
+        """
+        horizontal_dist = np.sqrt((self.camera.pos_x - led.pos_x) ** 2 + (self.camera.pos_y - led.pos_y) ** 2)
+        alpha = np.arctan((led.pos_z - self.camera.pos_z) / horizontal_dist)
+        if alpha == 0:
+            distance_per_layer = self.calc_traversed_dist_in_plane(led)
+        else:
+            distance_per_layer = self.calc_traversed_dist_per_layer_with_nonzero_alpha(alpha, led)
+
+        if not self.distance_calculation_is_consistent(distance_per_layer, led):
+            distance_per_layer = None
+        return distance_per_layer
+
+    def calc_traversed_dist_in_plane(self, led: LED) -> np.ndarray:
+        """
+        Calculate the distance traversed by light from an LED in a plane to the camera.
+
+        :param led: The LED light source
+        :type led: LED
+        :return: Array of distances traversed in each layer within the plane
+        :rtype: np.ndarray
+        """
+        distance_per_layer = np.zeros(self.layers.amount)
+        horizontal_dist = np.sqrt((self.camera.pos_x - led.pos_x) ** 2 + (self.camera.pos_y - led.pos_y) ** 2)
+        for layer in range(self.layers.amount):
+            layer_bottom = self.layers.borders[layer]
+            layer_top = self.layers.borders[layer + 1]
+            if layer_bottom <= self.camera.pos_z < layer_top:
+                distance_per_layer[layer] = horizontal_dist
+        return distance_per_layer
+
+    def calc_traversed_dist_per_layer_with_nonzero_alpha(self, alpha: float, led: LED) -> np.ndarray:
+        """
+        Calculate the distance traversed by light from an LED through each layer to the camera,
+        taking into account a non-zero angle of incidence.
+
+        :param alpha: The angle of incidence
+        :type alpha: float
+        :param led: The LED light source
+        :type led: LED
+        :return: Array of distances traversed in each layer considering the angle
+        :rtype: np.ndarray
+        """
+        distance_per_layer = np.zeros(self.layers.amount)
+        for layer in range(self.layers.amount):
+            layer_bottom = self.layers.borders[layer]
+            layer_top = self.layers.borders[layer + 1]
+            th = self.calc_traversed_height_in_layer(led.pos_z, layer_bottom, layer_top)
+            distance_per_layer[layer] = np.abs(th / np.sin(alpha))
+        return distance_per_layer
+
+    def calc_traversed_height_in_layer(self, led_height: float, layer_bot: float, layer_top: float) -> float:
+        """
+        Calculate the vertical distance (height) traversed by light from an LED within a layer.
+
+        :param led_height: The z-coordinate of the LED
+        :type led_height: float
+        :param layer_bot: The z-coordinate of the bottom of the layer
+        :type layer_bot: float
+        :param layer_top: The z-coordinate of the top of the layer
+        :type layer_top: float
+        :return: The vertical distance traversed within the layer
+        :rtype: float
+        """
+        top_end = max(self.camera.pos_z, led_height)
+        bot_end = min(self.camera.pos_z, led_height)
+        bot = max(bot_end, layer_bot)
+        top = min(top_end, layer_top)
+        h = top - bot
+        if h < 0:
+            h = 0
+        return h
+
+    def distance_calculation_is_consistent(self, distance_per_layer: np.ndarray, led: LED, silent=True) -> bool:
+        """
+        Check if the computed distance values for each layer are consistent with the Euclidean distance.
+
+        :param distance_per_layer: Array of distances traversed in each layer
+        :type distance_per_layer: np.ndarray
+        :param led: The LED light source
+        :type led: LED
+        :param silent: If set to False, prints out debugging information, defaults to True
+        :type silent: bool, optional
+        :return: True if computations are consistent, False otherwise
+        :rtype: bool
+        """
+        if np.abs(np.sum(distance_per_layer) - np.sqrt((self.camera.pos_x - led.pos_x) ** 2 +
+                                                       (self.camera.pos_y - led.pos_y) ** 2 +
+                                                       (self.camera.pos_z - led.pos_z) ** 2)) > 1e-6:
+            if not silent:
+                print("error in distance computation, camera_x: {}, camera_y: {} camera_z: {}, led_x: {}, led_y: {}, "
+                      "led_z: {}".format(
+                    self.camera.pos_x, self.camera.pos_y, self.camera.pos_z, led.pos_x, led.pos_y, led.pos_z))
+            return False
+        return True
+
+    def set_leds(self) -> None:
+        """
+        Initialize the LED instances involved in the experiment based on loaded data.
+
+        """
+        ids = self.get_led_ids()
+        x, y, z = self.get_led_positions(ids)
+        for i in range(len(ids)):
+            self.leds.append(LED(ids[i], x[i], y[i], z[i]))
+        self.num_leds = len(ids)
+
+    def get_led_ids(self) -> np.ndarray:
+        """
+        Retrieve the IDs for the LEDs involved in the experiment.
+
+        :return: Array of LED IDs
+        :rtype: np.ndarray
+        """
+        file_name_extension = '_merge' if self.merge_led_arrays != 'None' else ''
+        file_name = f'led_array_indices_{self.led_array:03d}{file_name_extension}.csv'
+        file_path = os.path.join(self.path, 'analysis', file_name)
+
+        led_array_indices = np.loadtxt(file_path, dtype=int)
+        return led_array_indices
+
+    def get_led_positions(self, ids: np.ndarray) -> List[np.ndarray]:
+        """
+        Retrieve the 3D positions for a set of LEDs.
+
+        :param ids: Array of LED identifiers
+        :type ids: np.ndarray
+        :return: List of arrays containing x, y, and z coordinates for each LED
+        :rtype: List[np.ndarray]
+        """
+        file_path = os.path.join(self.path, 'analysis', 'led_search_areas_with_coordinates.csv')
+        search_areas_all = np.loadtxt(file_path, delimiter=',')
+        search_areas_led_array = []
+        for led_id in ids:
+            search_areas_led_array.append(search_areas_all[led_id])
+        search_areas_led_array = np.array(search_areas_led_array)
+        return [search_areas_led_array[:, 3], search_areas_led_array[:, 4], search_areas_led_array[:, 5]]

ledsa/analysis/ExperimentData.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+
+from ledsa.analysis.ConfigDataAnalysis import ConfigDataAnalysis
+from ledsa.analysis.Experiment import Camera, Layers
+# Todo: Import init_function for request of missing data
+from ledsa.core.ConfigData import ConfigData
+
+
+@dataclass
+class ExperimentData:
+    """
+    Dataclass containing the data for the extinction coefficient calculation
+    from the experiment_data.txt input file.
+
+    :ivar config: Configuration data.
+    :type config: ConfigData
+    :ivar config_analysis: Analysis configuration data.
+    :type config_analysis: ConfigDataAnalysis
+    :ivar camera: Camera data.
+    :type camera: Camera
+    :ivar layers: Layer data.
+    :type layers: Layers
+    :ivar channels: List of channels.
+    :type channels: List[int]
+    :ivar led_arrays: List of LED arrays.
+    :type led_arrays: List[int]
+    :ivar n_cpus: Number of CPUs.
+    :type n_cpus: int
+    :ivar weighting_preference: Weighting preference for nonlinear solver.
+    :type weighting_preference: float
+    :ivar weighting_curvature: Weighting curvature for nonlinear solver.
+    :type weighting_curvature: float
+    :ivar num_iterations: Number of iterations.
+    :type num_iterations: int
+    :ivar num_ref_images: Number of reference images.
+    :type num_ref_images: int
+    :ivar reference_property: Reference property to be analysed.
+    :type reference_property: str
+    :ivar merge_led_arrays: Merge LED arrays option.
+    :type merge_led_arrays: str
+    :ivar lambda_reg: Regularization parameter for linear solver.
+    :type lambda_reg: float
+    """
+    def __init__(self, load_config_file=True):
+        self.config = ConfigData(load_config_file=load_config_file)
+        self.config_analysis = ConfigDataAnalysis(load_config_file=load_config_file)
+        self.camera = None
+        self.layers = None
+        self.channels = None
+        self.led_arrays = None
+        self.n_cpus = None
+        self.weighting_preference = None
+        self.weighting_curvature = None
+        self.num_iterations = None
+        self.num_ref_images = None
+        self.lambda_reg = None
+        self.reference_property = None
+        self.merge_led_arrays = None
+        self.solver = None
+        self.load_config_parameters()  # Todo: Does that belong here?
+
+    def load_config_parameters(self) -> None:
+        """
+        Load experiment data from configuration file.
+
+        """
+        config_analysis = self.config_analysis
+        num_layers = int(config_analysis['model_parameters']['num_layers'])
+        self.channels = config_analysis.get_list_of_values('DEFAULT', 'camera_channels')
+        self.num_ref_images = int(config_analysis['DEFAULT']['num_ref_images'])
+        self.weighting_preference = float(config_analysis['DEFAULT']['weighting_preference'])
+        self.weighting_curvature = float(config_analysis['DEFAULT']['weighting_curvature'])
+        self.lambda_reg = float(config_analysis['DEFAULT']['lambda_reg'])
+        self.num_iterations = int(config_analysis['DEFAULT']['num_iterations'])
+        self.reference_property = config_analysis['DEFAULT']['reference_property']
+        self.solver = config_analysis['DEFAULT']['solver']
+
+        self.led_arrays = config_analysis.get_list_of_values('model_parameters', 'led_array_indices')
+        if self.led_arrays is None:
+            config_analysis.in_led_array_indices()
+            config_analysis.save()
+        self.led_arrays = config_analysis.get_list_of_values('model_parameters', 'led_array_indices')
+
+        domain_bounds = config_analysis.get_list_of_values('model_parameters', 'domain_bounds', dtype=float)
+        if domain_bounds is None:
+            config_analysis.in_domain_bounds()
+            config_analysis.save()
+        domain_bounds = config_analysis.get_list_of_values('model_parameters', 'domain_bounds', dtype=float)
+
+        camera_position = config_analysis.get_list_of_values('experiment_geometry', 'camera_position', dtype=float)
+        if camera_position is None:
+            config_analysis.in_camera_position()
+            config_analysis.save()
+        camera_position = config_analysis.get_list_of_values('experiment_geometry', 'camera_position', dtype=float)
+
+        self.layers = Layers(num_layers, *domain_bounds)
+        self.camera = Camera(*camera_position)
+        self.n_cpus = int(config_analysis['DEFAULT']['num_cores'])
+        self.merge_led_arrays = str(self.config['analyse_positions']['merge_led_array_indices'])
+
+    def request_config_parameters(self) -> None:
+        """
+        Prompts the user to input missing parameters of analysis configuration and updates the configuration.
+
+        """
+        config = self.config_analysis
+        if config['experiment_geometry']['camera_position'] == 'None':
+            config.in_camera_position()
+            config.save()
+        if config['model_parameters']['num_layers'] == 'None':
+            config.in_num_layers()
+            config.save()
+        if config['model_parameters']['domain_bounds'] == 'None':
+            config.in_domain_bounds()
+            config.save()
+        if config['model_parameters']['led_array_indices'] == 'None':
+            config.in_led_array_indices()
+            config.save()