simcats-datasets 2.4.0__py3-none-any.whl

simcats_datasets/loading/pytorch.py

@@ -0,0 +1,426 @@
+"""Implementation of a pytorch dataset class. Can be used to train machine learning approaches with CSD data.
+
+@author: f.hader
+"""
+
+import math
+from typing import Callable, List, Union, Tuple
+
+import h5py
+import numpy as np
+from torch.utils.data import Dataset, ConcatDataset
+
+import simcats_datasets.loading.load_ground_truth
+import simcats_datasets.support_functions.data_preprocessing
+from simcats_datasets.loading import load_dataset
+from simcats_datasets.support_functions.pytorch_format_output import format_dict_csd_float_ground_truth_long
+
+
+class SimcatsDataset(Dataset):
+    """Pytorch Dataset class implementation for SimCATS datasets. Uses simcats_datasets to load and provide (training) data.
+    """
+
+    def __init__(self,
+                 h5_path: str,
+                 specific_ids: Union[range, List[int], np.ndarray, None] = None,
+                 load_ground_truth: Union[Callable, str, None] = None,
+                 data_preprocessors: Union[List[Union[str, Callable]], None] = None,
+                 ground_truth_preprocessors: Union[List[Union[str, Callable]], None] = None,
+                 format_output: Union[Callable, str, None] = None, preload: bool = True,
+                 max_concurrent_preloads: int = 100000,
+                 progress_bar: bool = False, ):
+        """Initializes an object for providing simcats_datasets data to pytorch.
+
+        Args:
+            h5_path: The path to the h5 file containing the dataset.
+            specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+                sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+                Default is None.
+            load_ground_truth: Defines the required type of ground truth data to be loaded. Accepts either a callable or
+                a string. Callables must be of the same structure/interface as load_zeros_masks defined in
+                simcats_datasets.loading.load_ground_truth. Strings must map to the function names of the
+                loading functions defined in simcats_datasets.loading.load_ground_truth. If this is None,
+                no ground truth are loaded is used, which restricts what output formats are possible. Default is None. \n
+                Example of available types (**full list at simcats_datasets.loading.load_ground_truth**): \n
+                - **'tct_masks'**: The Total Charge Transition (TCT) mask generated by SimCATS.
+                - **'tc_region_masks'**: Regions with a fixed number of total charges.
+                - **'tc_region_minus_tct_masks'**: Regions with a fixed number of total charges, but with zeros between
+                  the regions (at tcts).
+            data_preprocessors: Defines if data should be preprocessed. Accepts a list of callables or strings.
+                Callables must be of the same structure/interface as example_preprocessor defined in
+                simcats_datasets.support_functions.data_preprocessing. Strings must map to the function names of the
+                preprocessors defined in simcats_datasets.support_functions.data_preprocessing. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.data_preprocessing**): \n
+                - **'min_max_0_1'**: Min max scaling of the data to [0, 1]
+                - **'standardization'**: Standardization of the data (mean=0, std=1)
+                - **'add_newaxis'**: Adds new axis as first axis (required for UNET)
+            ground_truth_preprocessors: Defines if ground truth should be preprocessed. Accepts a list of callables or
+                strings. Callables must be of the same structure/interface as example_preprocessor defined in
+                simcats_datasets.support_functions.data_preprocessing. Strings must map to the function names of the
+                preprocessors defined in simcats_datasets.support_functions.data_preprocessing. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.data_preprocessing**): \n
+                - **'only_two_classes'**: Reduce the number of classes in a mask to 2 (set every pixel > 1 = 1)
+            format_output: Defines the required type of data format for the output. Accepts either a callable or a
+                string. Callables must be of the same structure/interface as format_dict_csd_float_ground_truth_long
+                defined in simcats_datasets.support_functions.pytorch_format_output. Strings must map to the function
+                names of the format functions defined in simcats_datasets.support_functions.pytorch_format_output. If
+                this is None, format_dict_csd_float_ground_truth_long is used, which does return the output as dict
+                with entries 'csd' and 'ground_truth' of dtype float and long, respectively. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.pytorch_format_output**): \n
+                - **'format_dict_csd_float_ground_truth_long'**: formats the output as dict with entries 'csd' and
+                  'ground_truth' of dtype float and long, respectively
+            preload: Enables preloading the whole dataset during the initialization (requires more RAM). Default is
+                True.
+            max_concurrent_preloads: Determines how many CSDs are concurrently loaded from the dataset during the
+                preload phase. This option only affects instances with preload = True. It allows to preload large
+                datasets (for which it might not be possible to load the whole dataset into the memory at once), by
+                loading them step by step and for example converting the CSDs to float32 with a corresponding data
+                preprocessor. Default is 100,000.
+            progress_bar: Determines whether to display a progress bar while loading data. Default is False.
+        """
+        self.__h5_path = h5_path
+        self.__specific_ids = specific_ids
+        # set up the load ground truth function. Could be None, function referenced by string, or callable
+        if load_ground_truth is None:
+            self.__load_ground_truth = None
+        else:
+            if isinstance(load_ground_truth, str):
+                self.__load_ground_truth = getattr(simcats_datasets.loading.load_ground_truth, load_ground_truth)
+            else:
+                self.__load_ground_truth = load_ground_truth
+        # set up the data preprocessors. Could be None, functions referenced by strings, or callables
+        if data_preprocessors is None:
+            self.__data_preprocessors = data_preprocessors
+        else:
+            self.__data_preprocessors = [
+                i if not isinstance(i, str) else getattr(simcats_datasets.support_functions.data_preprocessing, i) for i
+                in data_preprocessors]
+        # set up the ground truth preprocessors. Could be None, functions referenced by strings, or callables
+        if ground_truth_preprocessors is None:
+            self.__ground_truth_preprocessors = ground_truth_preprocessors
+        else:
+            if self.load_ground_truth is None:
+                raise ValueError("If load_ground_truth is None. ground_truth_preprocessors should also be None")
+            self.__ground_truth_preprocessors = [
+                i if not isinstance(i, str) else getattr(simcats_datasets.support_functions.data_preprocessing, i) for i
+                in ground_truth_preprocessors]
+        # set up the output format function. Could be None, function referenced by string, or callable
+        if format_output is None:
+            self.__format_output = format_dict_csd_float_ground_truth_long
+        else:
+            if isinstance(format_output, str):
+                self.__format_output = getattr(simcats_datasets.support_functions.pytorch_format_output,
+                    format_output, )
+            else:
+                self.__format_output = format_output
+        self.__preload = preload
+        self.__progress_bar = progress_bar
+        with h5py.File(h5_path, "r") as h5_file:
+            # setup available ids (if specific ids were supplied, they are mapped to a new range from 0 to len(specific_ids)
+            self.__num_ids = len(
+                load_dataset(file=h5_file, load_csds=False, load_ids=True, specific_ids=self.specific_ids,
+                    progress_bar=self.progress_bar, ).ids)
+            # preprocess an exemplary image to get final shape (some preprocessors might adjust the shape)
+            _temp_csd = \
+            load_dataset(file=h5_file, load_csds=True, specific_ids=[0], progress_bar=self.progress_bar, ).csds[0]
+            if self.data_preprocessors is not None:
+                for processor in self.data_preprocessors:
+                    _temp_csd = processor(_temp_csd)
+            self.__shape = (self.__num_ids, *np.squeeze(_temp_csd).shape)
+            # preload all data if requested
+            if self.preload:
+                self.__csds = []
+                self.__ground_truths = []
+                # load and save data, at most max_concurrent_ids at a time
+                for i in range(math.ceil(self.__num_ids / max_concurrent_preloads)):
+                    _ids = range(i * max_concurrent_preloads,
+                        np.min([(i + 1) * max_concurrent_preloads, self.__num_ids]))
+                    if self.specific_ids is not None:
+                        _ids = [self.specific_ids[i] for i in _ids]
+                    # load
+                    _temp_csds = [csd for csd in
+                        load_dataset(file=h5_file, specific_ids=_ids, progress_bar=self.progress_bar, ).csds]
+                    # preprocess data
+                    if self.data_preprocessors is not None:
+                        for processor in self.data_preprocessors:
+                            _temp_csds = processor(_temp_csds)
+                    self.__csds.extend(_temp_csds)
+                    del _temp_csds
+                    try:
+                        _temp_ground_truths = [gt for gt in
+                            self.load_ground_truth(file=h5_file, specific_ids=_ids, progress_bar=self.progress_bar, )]
+                        # preprocess ground truth
+                        if self.ground_truth_preprocessors is not None:
+                            for processor in self.ground_truth_preprocessors:
+                                _temp_ground_truths = processor(_temp_ground_truths)
+                        self.__ground_truths.extend(_temp_ground_truths)
+                        del _temp_ground_truths
+                    except TypeError:
+                        pass
+
+    @property
+    def h5_path(self) -> str:
+        return self.__h5_path
+
+    @property
+    def specific_ids(self) -> Union[range, List[int], np.ndarray, None]:
+        return self.__specific_ids
+
+    @property
+    def load_ground_truth(self) -> Callable:
+        return self.__load_ground_truth
+
+    @property
+    def data_preprocessors(self) -> Union[List[Callable], None]:
+        return self.__data_preprocessors
+
+    @property
+    def ground_truth_preprocessors(self) -> Union[List[Callable], None]:
+        return self.__ground_truth_preprocessors
+
+    @property
+    def format_output(self) -> Callable:
+        return self.__format_output
+
+    @property
+    def preload(self) -> bool:
+        return self.__preload
+
+    @property
+    def progress_bar(self) -> bool:
+        return self.__progress_bar
+
+    @property
+    def shape(self) -> Tuple[int]:
+        return self.__shape
+
+    def __len__(self):
+        """
+        Returns the number of CSDs in the dataset.
+        """
+        return self.__num_ids
+
+    def __getitem__(self, idx: int):
+        """
+        Retrieves a csd and the corresponding ground truth at given index idx.
+
+        Args:
+            idx: The id of the csd and ground truth to be returned.
+        """
+        if self.preload:
+            csd = self.__csds[idx]
+            try:
+                ground_truth = self.__ground_truths[idx]
+            except IndexError:
+                ground_truth = None
+        else:
+            # create h5_file here for non-preloaded mode. we can't create it before, because non preloaded Dataset used
+            # with multiple workers is not able to pickle HDF5 files!
+            if not hasattr(self, "__h5_file"):
+                self.__h5_file = h5py.File(self.h5_path, mode="r")
+            if self.specific_ids is not None:
+                idx = self.specific_ids[idx]
+            # load data
+            csd = load_dataset(file=self.__h5_file, specific_ids=[idx], progress_bar=self.progress_bar).csds[0]
+            # preprocess data
+            if self.data_preprocessors is not None:
+                for processor in self.data_preprocessors:
+                    csd = processor(csd)
+            # load ground truth
+            try:
+                ground_truth = \
+                self.load_ground_truth(file=self.__h5_file, specific_ids=[idx], progress_bar=self.progress_bar)[0]
+                # preprocess ground truth
+                if self.ground_truth_preprocessors is not None:
+                    for processor in self.ground_truth_preprocessors:
+                        ground_truth = processor(ground_truth)
+            except TypeError:
+                ground_truth = None
+        return self.format_output(csd=csd, ground_truth=ground_truth, idx=idx)
+
+    def __repr__(self):
+        return (f"{self.__class__.__name__}(\n"
+                f"\th5_path={self.h5_path},\n"
+                f"\tspecific_ids={self.specific_ids},\n"
+                f"\tload_ground_truth={self.load_ground_truth.__name__ if self.load_ground_truth is not None else None},\n"
+                f"\tdata_preprocessors=[{[', '.join([func.__name__ for func in self.data_preprocessors]) if self.data_preprocessors is not None else None][0]}],\n"
+                f"\tground_truth_preprocessors=[{[', '.join([func.__name__ for func in self.ground_truth_preprocessors]) if self.ground_truth_preprocessors is not None else None][0]}],\n"
+                f"\tformat_output={self.format_output.__name__},\n"
+                f"\tpreload={self.preload},\n"
+                f"\tprogress_bar={self.progress_bar}\n"
+                f")")
+
+    def __del__(self):
+        if hasattr(self, "__h5_file"):
+            self.__h5_file.close()
+
+
+class SimcatsConcatDataset(ConcatDataset):
+    def __init__(self,
+                 h5_paths: List[str],
+                 specific_ids: Union[List[Union[range, int, np.ndarray, None]], None] = None,
+                 load_ground_truth: Union[Callable, str, None] = None,
+                 data_preprocessors: Union[List[Union[str, Callable]], None] = None,
+                 ground_truth_preprocessors: Union[List[Union[str, Callable]], None] = None,
+                 format_output: Union[Callable, str, None] = None, preload: bool = True,
+                 max_concurrent_preloads: int = 100000,
+                 progress_bar: bool = False, ):
+        """Initializes an object for providing concatenated simcats_datasets data to pytorch.
+
+        Args:
+            h5_paths: The paths to the h5 files containing the datasets to be concatenated.
+            specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+                sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+                Expects a list of specific_id settings, with one entry for each provided h5_path. Default is None.
+            load_ground_truth: Defines the required type of ground truth data to be loaded. Accepts either a callable or
+                a string. Callables must be of the same structure/interface as load_zeros_masks defined in
+                simcats_datasets.loading.load_ground_truth. Strings must map to the function names of the
+                loading functions defined in simcats_datasets.loading.load_ground_truth. If this is None,
+                no ground truth are loaded is used, which restricts what output formats are possible. Default is None. \n
+                Example of available types (**full list at simcats_datasets.loading.load_ground_truth**): \n
+                - **'tct_masks'**: The Total Charge Transition (TCT) mask generated by SimCATS.
+                - **'tc_region_masks'**: Regions with a fixed number of total charges.
+                - **'tc_region_minus_tct_masks'**: Regions with a fixed number of total charges, but with zeros between
+                  the regions (at tcts).
+            data_preprocessors: Defines if data should be preprocessed. Accepts a list of callables or strings.
+                Callables must be of the same structure/interface as example_preprocessor defined in
+                simcats_datasets.support_functions.data_preprocessing. Strings must map to the function names of the
+                preprocessors defined in simcats_datasets.support_functions.data_preprocessing. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.data_preprocessing**): \n
+                - **'min_max_0_1'**: Min max scaling of the data to [0, 1]
+                - **'standardization'**: Standardization of the data (mean=0, std=1)
+                - **'add_newaxis'**: Adds new axis as first axis (required for UNET)
+            ground_truth_preprocessors: Defines if ground truth should be preprocessed. Accepts a list of callables or
+                strings. Callables must be of the same structure/interface as example_preprocessor defined in
+                simcats_datasets.support_functions.data_preprocessing. Strings must map to the function names of the
+                preprocessors defined in simcats_datasets.support_functions.data_preprocessing. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.data_preprocessing**): \n
+                - **'only_two_classes'**: Reduce the number of classes in a mask to 2 (set every pixel > 1 = 1)
+            format_output: Defines the required type of data format for the output. Accepts either a callable or a
+                string. Callables must be of the same structure/interface as format_dict_csd_float_ground_truth_long
+                defined in simcats_datasets.support_functions.pytorch_format_output. Strings must map to the function
+                names of the format functions defined in simcats_datasets.support_functions.pytorch_format_output. If
+                this is None, format_dict_csd_float_ground_truth_long is used, which does return the output as dict
+                with entries 'csd' and 'ground_truth' of dtype float and long, respectively. Default is None. \n
+                Example of available types (**full list at simcats_datasets.support_functions.pytorch_format_output**): \n
+                - **'format_dict_csd_float_ground_truth_long'**: formats the output as dict with entries 'csd' and
+                  'ground_truth' of dtype float and long, respectively
+            preload: Enables preloading the whole dataset during the initialization (requires more RAM). Default is
+                True.
+            max_concurrent_preloads: Determines how many CSDs are concurrently loaded from the dataset during the
+                preload phase. This option only affects instances with preload = True. It allows to preload large
+                datasets (for which it might not be possible to load the whole dataset into the memory at once), by
+                loading them step by step and for example converting the CSDs to float32 with a corresponding data
+                preprocessor. Default is 100.000.
+            progress_bar: Determines whether to display a progress bar while loading data. Default is False.
+        """
+        _datasets = list()
+        if specific_ids is not None and len(specific_ids) != len(h5_paths):
+            raise IndexError("Specific_ids were provided but with a different number of entries than h5_paths! If "
+                             "specific_ids are provided they need to contain the same number of entries!")
+        for i, path in enumerate(h5_paths):
+            if specific_ids is not None and len(specific_ids) == len(h5_paths):
+                temp_specific_ids = specific_ids[i]
+            else:
+                temp_specific_ids = None
+            _datasets.append(
+                SimcatsDataset(h5_path=path, specific_ids=temp_specific_ids, load_ground_truth=load_ground_truth,
+                               data_preprocessors=data_preprocessors,
+                               ground_truth_preprocessors=ground_truth_preprocessors, format_output=format_output,
+                               preload=preload, max_concurrent_preloads=max_concurrent_preloads,
+                               progress_bar=progress_bar))
+        super().__init__(_datasets)
+        self.__h5_paths = h5_paths
+        self.__specific_ids = specific_ids
+        # set up the load ground truth function. Could be None, function referenced by string, or callable
+        if load_ground_truth is None:
+            self.__load_ground_truth = None
+        else:
+            if isinstance(load_ground_truth, str):
+                self.__load_ground_truth = getattr(simcats_datasets.loading.load_ground_truth, load_ground_truth)
+            else:
+                self.__load_ground_truth = load_ground_truth
+        # set up the data preprocessors. Could be None, functions referenced by strings, or callables
+        if data_preprocessors is None:
+            self.__data_preprocessors = data_preprocessors
+        else:
+            self.__data_preprocessors = [
+                i if not isinstance(i, str) else getattr(simcats_datasets.support_functions.data_preprocessing, i) for i
+                in data_preprocessors]
+        # set up the ground truth preprocessors. Could be None, functions referenced by strings, or callables
+        if ground_truth_preprocessors is None:
+            self.__ground_truth_preprocessors = ground_truth_preprocessors
+        else:
+            if self.load_ground_truth is None:
+                raise ValueError("If load_ground_truth is None, ground_truth_preprocessors should also be None")
+            self.__ground_truth_preprocessors = [
+                i if not isinstance(i, str) else getattr(simcats_datasets.support_functions.data_preprocessing, i) for i
+                in ground_truth_preprocessors]
+        # set up the output format function. Could be None, function referenced by string, or callable
+        if format_output is None:
+            self.__format_output = format_dict_csd_float_ground_truth_long
+        else:
+            if isinstance(format_output, str):
+                self.__format_output = getattr(simcats_datasets.support_functions.pytorch_format_output,
+                    format_output, )
+            else:
+                self.__format_output = format_output
+        self.__preload = preload
+        self.__progress_bar = progress_bar
+        # get dataset shapes and check if all shapes are the same
+        shape = None
+        for dataset in _datasets:
+            if shape is None:
+                shape = dataset.shape[1:]
+            elif dataset.shape[1:] != shape:
+                raise ValueError(f"The shape of the SimcatsDataset CSDs should be identical but found shapes "
+                                 f"{[dataset.shape[1:] for dataset in _datasets]}")
+        self.__shape = (len(self), *shape)
+
+    @property
+    def h5_paths(self) -> List[str]:
+        return self.__h5_paths
+
+    @property
+    def specific_ids(self) -> Union[List[Union[range, List[int], np.ndarray, None]], None]:
+        return self.__specific_ids
+
+    @property
+    def load_ground_truth(self) -> Callable:
+        return self.__load_ground_truth
+
+    @property
+    def data_preprocessors(self) -> Union[List[Callable], None]:
+        return self.__data_preprocessors
+
+    @property
+    def ground_truth_preprocessors(self) -> Union[List[Callable], None]:
+        return self.__ground_truth_preprocessors
+
+    @property
+    def format_output(self) -> Callable:
+        return self.__format_output
+
+    @property
+    def preload(self) -> bool:
+        return self.__preload
+
+    @property
+    def progress_bar(self) -> bool:
+        return self.__progress_bar
+
+    @property
+    def shape(self) -> Tuple[int]:
+        return self.__shape
+
+    def __repr__(self):
+        return (f"{self.__class__.__name__}(\n"
+                f"\th5_paths={self.h5_paths},\n"
+                f"\tspecific_ids={self.specific_ids},\n"
+                f"\tload_ground_truth={self.load_ground_truth.__name__},\n"
+                f"\tdata_preprocessors=[{[', '.join([func.__name__ for func in self.data_preprocessors]) if self.data_preprocessors is not None else None][0]}],\n"
+                f"\tground_truth_preprocessors=[{[', '.join([func.__name__ for func in self.ground_truth_preprocessors]) if self.ground_truth_preprocessors is not None else None][0]}],\n"
+                f"\tformat_output={self.format_output.__name__},\n"
+                f"\tpreload={self.preload},\n"
+                f"\tprogress_bar={self.progress_bar}\n"
+                f")")

simcats_datasets/support_functions/__init__.py

@@ -0,0 +1 @@
+"""Module with support functions for different main functionalities."""

simcats_datasets/support_functions/_json_encoders.py

@@ -0,0 +1,51 @@
+"""JSON encoders that are required to encode numpy arrays and xarray DataArrays while saving datasets.
+
+@author: f.hader
+"""
+
+import json
+import numpy as np
+from xarray import DataArray
+
+
+class MultipleJsonEncoders(json.JSONEncoder):
+    """Combine multiple JSON encoders"""
+
+    def __init__(self, *encoders):
+        super().__init__()
+        self.encoders = encoders
+        self.args = ()
+        self.kwargs = {}
+
+    def default(self, obj):
+        for encoder in self.encoders:
+            try:
+                return encoder(*self.args, **self.kwargs).default(obj)
+            except TypeError:
+                pass
+        raise TypeError(f'Object of type {obj.__class__.__name__} is not JSON serializable')
+
+    def __call__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+        enc = json.JSONEncoder(*args, **kwargs)
+        enc.default = self.default
+        return enc
+
+
+class DataArrayEncoder(json.JSONEncoder):
+    """JSON encoder for DataArrays."""
+
+    def default(self, obj):
+        if isinstance(obj, DataArray):
+            return obj.to_dict()
+        return json.JSONEncoder.default(self, obj)
+
+
+class NumpyEncoder(json.JSONEncoder):
+    """JSON encoder for numpy arrays."""
+
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return json.JSONEncoder.default(self, obj)

simcats_datasets/support_functions/clip_line_to_rectangle.py

@@ -0,0 +1,191 @@
+"""Helper functions for clipping lines into rectangles (into the CSD space).
+
+Used to clip single transition lines into the CSD space to generate transition specific labels with the function
+`get_lead_transition_labels` from `simcats_datasets.support_functions.get_lead_transition_labels`.
+
+@author: f.hader
+"""
+
+from typing import Tuple, List, Union
+
+
+def clip_slope_line_to_rectangle(slope: float, point: Tuple[float, float], rect_corners: List[Tuple[float, float]],
+                                 is_start: bool = True) -> Union[Tuple[Tuple[float, float], Tuple[float, float]], None]:
+    """Clips a line segment with a given slope to a rectangle, extending it to either positive or negative infinity from the provided point.
+
+    Args:
+        slope: The slope of the line.
+        point: A tuple (x, y) representing the starting or ending point of the line segment.
+        rect_corners: A list of four tuples, each representing the corner points of the rectangle.
+        is_start: Specifies whether the line extends to positive infinity (True) or negative infinity (False) from the
+            provided point. Default is True (positive infinity).
+
+    Returns:
+        A tuple (start, end) representing the clipped line segment. Returns None if the line is entirely outside the
+        rectangle.
+
+    Notes:
+        - The function handles lines defined by a slope and a single point.
+        - The 'is_start' parameter determines whether the line extends to positive or negative infinity from the
+          provided point.
+    """
+    x_range = (min(rect_corners, key=lambda p: p[0])[0], max(rect_corners, key=lambda p: p[0])[0])
+
+    if is_start:
+        start = point
+        end = (x_range[1] + 1, point[1] + slope * (x_range[1] + 1 - point[0]))
+    else:
+        start = (x_range[0] - 1, point[1] - slope * (point[0] - x_range[0] + 1))
+        end = point
+
+    # Use the clip_line_to_rectangle function to clip the line
+    return clip_point_line_to_rectangle(start, end, rect_corners)
+
+
+def clip_infinite_slope_line_to_rectangle(slope: float, point: Tuple[float, float],
+                                          rect_corners: List[Tuple[float, float]]) -> Union[
+    Tuple[Tuple[float, float], Tuple[float, float]], None]:
+    """Clips a line segment with a given slope to a rectangle, extending it to positive and negative infinity from the provided point.
+
+    Args:
+        slope: The slope of the line.
+        point: A tuple (x, y) representing the starting or ending point of the line segment.
+        rect_corners: A list of four tuples, each representing the corner points of the rectangle.
+
+    Returns:
+        A tuple (start, end) representing the clipped line segment. Returns None if the line is entirely outside the
+        rectangle.
+
+    Notes:
+        - The function handles lines defined by a slope and a single point.
+    """
+    x_range = (min(rect_corners, key=lambda p: p[0])[0], max(rect_corners, key=lambda p: p[0])[0])
+
+    start = (x_range[0] - 1, point[1] - slope * (point[0] - x_range[0] + 1))
+    end = (x_range[1] + 1, point[1] + slope * (x_range[1] + 1 - point[0]))
+
+    # Use the clip_line_to_rectangle function to clip the line
+    return clip_point_line_to_rectangle(start, end, rect_corners)
+
+
+def clip_point_line_to_rectangle(start: Tuple[float, float], end: Tuple[float, float],
+                                 rect_corners: List[Tuple[float, float]]) -> Union[
+    Tuple[Tuple[float, float], Tuple[float, float]], None]:
+    """Clips a line segment defined by its start and end points to a rectangle.
+
+    Args:
+        start: A tuple (x, y) representing the start point of the line.
+        end: A tuple (x, y) representing the end point of the line.
+        rect_corners: A list of four tuples, each representing the corner points of the rectangle.
+
+    Returns:
+        A tuple representing the clipped line segment (start, end) if any part of the line is inside the rectangle.
+        Returns None if the line is entirely outside the rectangle.
+
+    Notes:
+        - The function handles lines defined by two points.
+        - The function handles the case when the line is entirely inside the rectangle.
+    """
+    if all(is_point_inside_rectangle(point, rect_corners) for point in (start, end)):
+        # The entire line is inside the rectangle
+        return start, end
+
+    clipped_start = None
+    clipped_end = None
+
+    # Check if the start point is inside the rectangle
+    if is_point_inside_rectangle(start, rect_corners):
+        clipped_start = start
+
+    # Check if the end point is inside the rectangle
+    if is_point_inside_rectangle(end, rect_corners):
+        clipped_end = end
+
+    # Iterate through pairs of adjacent corner points to check for intersections
+    for rect_point1, rect_point2 in zip(rect_corners, rect_corners[1:] + [rect_corners[0]]):
+        # Calculate the intersection point between the line and the rectangle edge
+        intersection = line_intersection(start, end, rect_point1, rect_point2)
+        if intersection is not None:
+            if clipped_start is None:
+                clipped_start = intersection
+            elif clipped_end is None:
+                clipped_end = intersection
+            if clipped_start is not None and clipped_end is not None:
+                break
+
+    return clipped_start, clipped_end
+
+
+def is_point_inside_rectangle(point: Tuple[float, float], rect_corners: List[Tuple[float, float]]) -> bool:
+    """Checks if a point is inside a rectangle defined by its corner points.
+
+    Args:
+        point: A tuple (x, y) representing the point to be checked.
+        rect_corners: A list of four tuples, each representing the corner points of the rectangle. it is assumed that
+            these are sorted so that they from a course around the rectangle. Thus, the first and third (or
+            alternatively the second and fourth) define the rectangle.
+
+    Returns:
+        True if the point is inside the rectangle, False otherwise.
+    """
+    x, y = point
+    x1, y1 = rect_corners[0]
+    x2, y2 = rect_corners[2]
+    return x1 <= x <= x2 and y1 <= y <= y2
+
+
+def line_intersection(p1: Tuple[float, float], p2: Tuple[float, float], q1: Tuple[float, float],
+                      q2: Tuple[float, float]) -> Union[Tuple[float, float], None]:
+    """Calculates the intersection point between two line segments defined by their respective endpoints.
+
+    Args:
+        p1: A tuple (x, y) representing the first endpoint of the first line.
+        p2: A tuple (x, y) representing the second endpoint of the first line.
+        q1: A tuple (x, y) representing the first endpoint of the second line.
+        q2: A tuple (x, y) representing the second endpoint of the second line.
+
+    Returns:
+        A tuple (x, y) representing the intersection point if the lines intersect. Returns None if the lines are
+        parallel or do not intersect.
+    """
+    x1, y1 = p1
+    x2, y2 = p2
+    x3, y3 = q1
+    x4, y4 = q2
+
+    # denominator
+    den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+    if den == 0:
+        return None  # Lines are parallel or coincident
+
+    t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / den
+    u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / den
+
+    if 0 <= t <= 1 and 0 <= u <= 1:
+        intersection_x = x1 + t * (x2 - x1)
+        intersection_y = y1 + t * (y2 - y1)
+        return (intersection_x, intersection_y)
+    else:
+        return None
+
+
+def create_rectangle_corners(x_range: Tuple[float, float], y_range: Tuple[float, float]) -> List[Tuple[float, float]]:
+    """Creates rectangle corner points that form a rectangle around the specified x and y value ranges.
+
+    Args:
+        x_range: A tuple (x_min, x_max) representing the minimum and maximum x values.
+        y_range: A tuple (y_min, y_max) representing the minimum and maximum y values.
+
+    Returns:
+        A list of four tuples, each representing the corner points of the rectangle in the following order: bottom-left,
+        bottom-right, top-right, top-left.
+    """
+    x_min, x_max = x_range
+    y_min, y_max = y_range
+
+    bottom_left = (x_min, y_min)
+    bottom_right = (x_max, y_min)
+    top_right = (x_max, y_max)
+    top_left = (x_min, y_max)
+
+    return [bottom_left, bottom_right, top_right, top_left]