funcnodes-span 0.2.5__tar.gz → 0.3.1__tar.gz

funcnodes_span-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Linkdlab GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{funcnodes_span-0.2.5 → funcnodes_span-0.3.1}/PKG-INFO

@@ -1,25 +1,28 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.2.5
-Summary: 
-Home-page: https://linkdlab.de/
+Version: 0.3.1
+Summary: Spectral Peak ANalysis (SPAN) for funcnodes
+License: MIT
 Author: Kourosh Rezaei
 Author-email: kouroshrezaei90@gmail.com
 Requires-Python: >=3.11
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: Numba
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: funcnodes
-Requires-Dist: funcnodes-core (>=0.1.4)
+Requires-Dist: funcnodes-lmfit
 Requires-Dist: funcnodes_numpy
 Requires-Dist: funcnodes_pandas
 Requires-Dist: funcnodes_plotly
 Requires-Dist: lmfit
-Requires-Dist: pentapy
 Requires-Dist: pybaselines
 Requires-Dist: scipy
-Project-URL: Repository, https://github.com/kouroshrezaei/funcnodes_span
+Project-URL: download, https://pypi.org/project/funcnodes-span/#files
+Project-URL: homepage, https://github.com/Linkdlab/funcnodes_span
+Project-URL: source, https://github.com/Linkdlab/funcnodes_span
+Project-URL: tracker, https://github.com/Linkdlab/funcnodes_span/issues
 Description-Content-Type: text/markdown
 
 Spectral Peak ANalysis (SPAN) for funcnodes

{funcnodes_span-0.2.5 → funcnodes_span-0.3.1}/funcnodes_span/__init__.py

@@ -4,12 +4,14 @@ from .normalization import NORM_NODE_SHELF as NORM
 from .smoothing import SMOOTH_NODE_SHELF as SMOOTH
 from .peak_analysis import PEAKS_NODE_SHELF as PEAK
 from .baseline import BASELINE_NODE_SHELF as BASELINE
+from funcnodes_lmfit import NODE_SHELF as LMFIT_NODE_SHELF
+from .curves import CURVES_NODE_SHELF
 
-__version__ = "0.2.5"
+__version__ = "0.3.1"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",
     description="Spectral analysis for funcnodes",
     nodes=[],
-    subshelves=[NORM, SMOOTH, BASELINE, PEAK],
+    subshelves=[NORM, SMOOTH, BASELINE, PEAK, CURVES_NODE_SHELF, LMFIT_NODE_SHELF],
 )

funcnodes_span-0.3.1/funcnodes_span/_baseline.py

@@ -0,0 +1,93 @@
+from typing import Tuple, Optional
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+from ._curves import knee_point_detection, outlier_detection_std
+
+
+def estimate_baseline_regions(
+    x: np.ndarray,
+    y: np.ndarray,
+    pre_flatted_y: Optional[np.ndarray] = None,
+    window: Optional[float] = None,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Estimate the baseline regions of a curve.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        The x values of the curve.
+    y : np.ndarray
+        The y values of the curve.
+    pre_flatted_y : np.ndarray, optional
+        The y values of the curve when flattet.
+    window : float, optional
+        The window size for the gaussian filter.relative to the x values. Default is 1% of the x values.
+
+    Returns
+    -------
+    y_bl : np.ndarray
+        The baseline of the curve, linearly interpolated between the baseline regions.
+    is_baseline_region : np.ndarray
+        A boolean array indicating the baseline region.
+    """
+
+    if window is None:
+        window = len(y) / 100  # default value as absolute number of points
+    else:
+        # if window is a float, the number of points is calculated as as if window is in x units
+        window = int(window / (np.median(np.diff(x)) if x is not None else 1) + 0.5)
+
+    window = max(1, window)
+
+    if pre_flatted_y is None:
+        pre_flatted_y = y
+
+    smoothed_baseline_corrected_y = gaussian_filter1d(pre_flatted_y, window)
+
+    percentage_cutoff = np.arange(0, 1, 0.0001)
+
+    abs_smoothed_baseline_corrected_y = (
+        smoothed_baseline_corrected_y + smoothed_baseline_corrected_y.min()
+    )
+
+    norm_smoothed_y = abs_smoothed_baseline_corrected_y / np.max(
+        abs_smoothed_baseline_corrected_y
+    )
+
+    norm_y = np.abs(pre_flatted_y)
+    norm_y = norm_y / np.max(norm_y)
+
+    cumulative_n_points = np.sum(norm_smoothed_y[:, None] < percentage_cutoff, axis=0)
+    cumulative_n_points = cumulative_n_points / np.max(cumulative_n_points)
+
+    elbow_idx, elbow_x, elbow_y = knee_point_detection(
+        percentage_cutoff, cumulative_n_points
+    )
+
+    is_baseline_region = norm_y <= elbow_x
+
+    outliers = outlier_detection_std(
+        x[is_baseline_region],
+        norm_y[is_baseline_region],
+        threshold=3,
+        max_iterations=9,
+    )
+
+    is_baseline_region[is_baseline_region] &= ~outliers
+
+    is_baseline_region = is_baseline_region.astype(float)
+
+    smoothed_is_baseline_region = gaussian_filter1d(is_baseline_region, window)
+    smoothed_is_baseline_region = (
+        smoothed_is_baseline_region >= 0.99 * smoothed_is_baseline_region.max()
+    )
+
+    if np.any(smoothed_is_baseline_region):
+        y_bl = np.interp(
+            x, x[smoothed_is_baseline_region], y[smoothed_is_baseline_region]
+        )
+    else:
+        y_bl = np.zeros_like(y)
+
+    return y_bl, smoothed_is_baseline_region

funcnodes_span-0.3.1/funcnodes_span/_curves.py

@@ -0,0 +1,104 @@
+import numpy as np
+from typing import Optional, Tuple
+
+
+def knee_point_detection(x, y) -> Tuple[int, float, float]:
+    """
+    Detect the knee (or elbow) point in a curve.
+
+    Parameters:
+    x (numpy array): X-values of the curve.
+    y (numpy array): Y-values of the curve.
+
+    Returns:
+    int: Index of the knee point in the input arrays.
+    float: X-value of the knee point.
+    float: Y-value of the knee point.
+
+    """
+    # Normalize x and y to have values between 0 and 1
+    x_normalized = (x - np.min(x)) / (np.max(x) - np.min(x))
+    y_normalized = (y - np.min(y)) / (np.max(y) - np.min(y))
+
+    # Line connecting the first and last points
+    line_vec = np.array(
+        [x_normalized[-1] - x_normalized[0], y_normalized[-1] - y_normalized[0]]
+    )
+    line_vec_norm = np.sqrt(
+        line_vec[0] ** 2 + line_vec[1] ** 2
+    )  # Length of the line vector
+    line_vec = line_vec / line_vec_norm  # Normalize the line vector
+
+    # Calculate the distances from all points to the line
+    vec_from_first = np.column_stack(
+        [x_normalized - x_normalized[0], y_normalized - y_normalized[0]]
+    )
+    scalar_proj = np.dot(vec_from_first, line_vec)
+    vec_along_line = np.outer(scalar_proj, line_vec)
+    vec_to_line = vec_from_first - vec_along_line
+
+    # Compute the distances
+    distances = np.sqrt(np.sum(vec_to_line**2, axis=1))
+
+    # Find the index of the maximum distance (knee point)
+    knee_index = np.argmax(distances)
+
+    return knee_index, x[knee_index], y[knee_index]
+
+
+def estimate_noise(
+    x, y, is_baseline_region: Optional[np.ndarray] = None, std_factor: float = 3
+) -> float:
+    """
+    Estimate the noise level in a signal.
+    x (numpy array): X-values of the signal.
+    y (numpy array): Y-values of the signal, assumed to be baseline corrected
+    baseline_region (numpy array): Boolean array indicating the baseline regions,
+        here the noise will be estamated. Calcualted automatically if not provided.
+    std_factor (float): Factor to multiply the standard deviation of the baseline region to estimate the noise level.
+    """
+    if is_baseline_region is None:
+        from ._baseline import estimate_baseline_regions
+
+        ybl, is_baseline_region = estimate_baseline_regions(x, y)
+        if is_baseline_region.sum() == 0:
+            raise ValueError("No baseline region found in the input data.")
+
+    std = np.std(y[is_baseline_region])
+    noise = std_factor * std
+    return noise
+
+
+def outlier_detection_std(
+    x: np.ndarray, y: np.ndarray, threshold: float = 3, max_iterations: int = 1
+) -> np.ndarray:
+    """
+    Detect outliers in a signal based on the standard deviation of the signal.
+
+    Parameters:
+    x (numpy array): X-values of the signal.
+    y (numpy array): Y-values of the signal.
+    threshold (float): Threshold for the standard deviation to detect outliers.
+    max_iterations (int): Maximum number of iterations to detect outliers.
+
+    Returns:
+    numpy array: A boolean array where True indicates an outlier in the signal.
+    """
+
+    is_outlier = np.zeros_like(y, dtype=bool)
+    n_outliers = 0
+    for _ in range(max_iterations):
+        new_outliers = y[~is_outlier]
+        if new_outliers.size == 0:  # Handle the case of no non-outliers left
+            break
+
+        std = np.nanstd(new_outliers)
+        mean = np.nanmean(new_outliers)
+        is_outlier[~is_outlier] = np.abs(y[~is_outlier] - mean) > threshold * std
+
+        current_outliers = is_outlier.sum()
+        if current_outliers == n_outliers:
+            break
+        n_outliers = current_outliers
+
+    return is_outlier