funcnodes-span 0.2.1__tar.gz → 0.2.3__tar.gz

{funcnodes_span-0.2.1 → funcnodes_span-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.2.1
+Version: 0.2.3
 Summary: 
 Home-page: https://linkdlab.de/
 Author: Kourosh Rezaei

{funcnodes_span-0.2.1 → funcnodes_span-0.2.3}/funcnodes_span/__init__.py

@@ -5,7 +5,7 @@ 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
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",

funcnodes_span-0.2.3/funcnodes_span/normalization.py

@@ -0,0 +1,161 @@
+from typing import Literal, Tuple
+from funcnodes import NodeDecorator, Shelf
+import numpy as np
+from scipy.interpolate import interp1d
+from exposedfunctionality import controlled_wrapper
+import funcnodes as fn
+
+
+class NormMode(fn.DataEnum):
+    ZERO_ONE = "zero_one"
+    MINUS_ONE_ONE = "minus_one_one"
+    SUM_ABS = "sum_abs"
+    SUM = "sum"
+    EUCLIDEAN = "euclidean"
+    MEAN_STD = "mean_std"
+    MAX = "max"
+
+
+@NodeDecorator(id="span.basics.norm", name="Normalization node")
+def _norm(array: np.ndarray, mode: NormMode = NormMode.ZERO_ONE) -> np.ndarray:
+    # """
+    # Apply different normalizations to the array.
+
+    # Args:
+    #     array (np.ndarray): The input array to be normalized.
+    #     mode (NormMode): The normalization mode to apply. Defaults to NormMode.ZERO_ONE.
+
+    # Returns:
+    #     np.ndarray: The normalized array.
+
+    # Raises:
+    #     ValueError: If an unsupported normalization mode is provided.
+    # """
+    mode = NormMode.v(mode)
+    normalization_methods = {
+        NormMode.ZERO_ONE.value: lambda x: (x - np.amin(x)) / (np.amax(x) - np.amin(x)),
+        NormMode.MINUS_ONE_ONE.value: lambda x: 2
+        * ((x - np.amin(x)) / (np.amax(x) - np.amin(x)))
+        - 1,
+        NormMode.SUM_ABS.value: lambda x: x / np.abs(x).sum(),
+        NormMode.SUM.value: lambda x: x / x.sum(),
+        NormMode.EUCLIDEAN.value: lambda x: x / np.sqrt((x**2).sum()),
+        NormMode.MEAN_STD.value: lambda x: (x - x.mean()) / x.std(),
+        NormMode.MAX.value: lambda x: x / x.max(),
+    }
+    if mode not in normalization_methods.keys():
+        raise ValueError(f"Unsupported normalization mode: {mode}")
+    return normalization_methods[mode](array)
+
+
+def density_normalization(
+    x: np.ndarray,
+    y: np.ndarray,
+    num_points: int = None,
+    distance_estimation: Literal["median", "mean", "min", "max"] = "median",
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Redistributes the x and y coordinates to have evenly spaced x-values while retaining original points.
+
+    Parameters:
+        x (np.ndarray): Uneven, unsorted x coordinates.
+        y (np.ndarray): Corresponding y values.
+        num_points (int, optional): Total number of points in the final grid.
+                                    Must be greater than or equal to the number of unique original x values.
+                                    If None, it is estimated based on the specified distance estimation method.
+        distance_estimation (Literal["median", "mean", "min", "max"], optional):
+            Method to estimate the spacing between points when num_points is not provided.
+            Options include "median", "mean", "min", "max". Defaults to "median".
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray]:
+            - x_new: Evenly spaced x coordinates including original x points.
+            - y_new: Corresponding interpolated y values."""
+    # Convert inputs to numpy arrays
+    x = np.array(x)
+    y = np.array(y)
+
+    # if x is already evenly spaced, return the input
+    if len(np.unique(np.diff(x))) == 1:
+        return x, y
+
+    # Sort the data based on x values
+    sorted_indices = np.argsort(x)
+    x_sorted = x[sorted_indices]
+    y_sorted = y[sorted_indices]
+
+    # Handle duplicate x-values by averaging their y-values
+    unique_x, indices, counts = np.unique(
+        x_sorted, return_index=True, return_counts=True
+    )
+    y_unique = np.array([y_sorted[i : i + c].mean() for i, c in zip(indices, counts)])
+
+    # Determine number of points for the evenly spaced grid
+
+    if num_points is None:
+        distance_func = {
+            "mean": np.mean,
+            "median": np.median,
+            "min": np.min,
+            "max": np.max,
+        }.get(distance_estimation, np.median)  # Default to median if key not found
+
+        unique_diffs = np.diff(unique_x)
+
+        # Handle the case where there is only one unique_x point
+        if len(unique_diffs) == 0:
+            num_points = 1
+        else:
+            estimated_diff = distance_func(unique_diffs)
+            total_range = unique_x.max() - unique_x.min()
+
+            # Prevent division by zero
+            if estimated_diff == 0:
+                num_points = len(unique_x)
+            else:
+                num_points = int(total_range / estimated_diff)
+    else:
+        num_points = int(num_points)
+    # Create evenly spaced x-values
+    x_new = np.linspace(unique_x.min(), unique_x.max(), num_points)
+
+    # Create an interpolation function
+    interp_func = interp1d(unique_x, y_unique, kind="linear", fill_value="extrapolate")
+
+    # Compute the interpolated y-values
+    y_new = interp_func(x_new)
+
+    return x_new, y_new
+
+
+@NodeDecorator(
+    id="span.norm.density",
+    name="Density normalization node",
+    description="Redistributes the x and y coordinates to have evenly spaced x-values while retaining original points.",
+    outputs=[
+        {
+            "name": "x_new",
+            "description": "Evenly spaced x coordinates including original x points.",
+        },
+        {
+            "name": "y_new",
+            "description": "Corresponding interpolated y values.",
+        },
+    ],
+)
+@controlled_wrapper(density_normalization, wrapper_attribute="__fnwrapped__")
+def density_normalization_node(
+    x: np.ndarray,
+    y: np.ndarray,
+    num_points: int = None,
+    distance_estimation: Literal["median", "mean", "min", "max"] = "median",
+) -> Tuple[np.ndarray, np.ndarray]:
+    return density_normalization(x, y, num_points, distance_estimation)
+
+
+NORM_NODE_SHELF = Shelf(
+    nodes=[_norm, density_normalization_node],
+    subshelves=[],
+    name="Normalization",
+    description="Normalization of the spectra",
+)

{funcnodes_span-0.2.1 → funcnodes_span-0.2.3}/funcnodes_span/peak_analysis.py

@@ -2,7 +2,7 @@ from funcnodes import NodeDecorator, Shelf
 import funcnodes as fn
 import numpy as np
 from exposedfunctionality import controlled_wrapper
-from typing import Optional, List, Tuple, Dict
+from typing import Optional, List, Tuple, Dict, Union
 from scipy.signal import find_peaks
 from scipy.stats import norm
 from scipy import signal, interpolate
@@ -13,6 +13,7 @@ import plotly.graph_objs as go
 from plotly.subplots import make_subplots
 import re
 from dataclasses import dataclass
+from .normalization import density_normalization
 
 
 @dataclass
@@ -21,6 +22,8 @@ class FittinInfo:
     best_values: dict
     data: np.ndarray
     userkws: dict
+    best_fit: np.ndarray
+    rsquared: float
 
 
 @dataclass
@@ -197,8 +200,8 @@ def compute_peak_properties(
 @NodeDecorator(id="span.basics.peaks", name="Peak finder")
 @controlled_wrapper(find_peaks, wrapper_attribute="__fnwrapped__")
 def peak_finder(
-    x_array: np.ndarray,
-    y_array: np.ndarray,
+    x: np.ndarray,
+    y: np.ndarray,
     noise_level: Optional[int] = None,
     height: Optional[float] = None,
     threshold: Optional[float] = None,
@@ -210,23 +213,46 @@ def peak_finder(
     plateau_size: Optional[int] = None,
 ) -> List[PeakProperties]:
     peak_lst = []
-    x_array = np.array(x_array, dtype=float)
-    y_array = np.array(y_array, dtype=float)
+    x = np.array(x, dtype=float)
+    y = np.array(y, dtype=float)
     noise_level = int(noise_level) if noise_level is not None else None
     height = float(height) if height is not None else None
     threshold = float(threshold) if threshold is not None else None
     distance = float(distance) if distance is not None else None
     prominence = float(prominence) if prominence is not None else None
     width = float(width) if width is not None else None
-    wlen = int(wlen) if wlen is not None else None
+    wlen = float(wlen) if wlen is not None else None
     rel_height = float(rel_height)
-    plateau_size = int(plateau_size) if plateau_size is not None else None
+    plateau_size = float(plateau_size) if plateau_size is not None else None
 
-    height = 0.05 * np.max(y_array) if height is None else height
+    height = 0.05 * np.max(y) if height is None else height
     noise_level = 5000 if noise_level is None else noise_level
 
+    if x is not None:
+        x, y = density_normalization(
+            x,
+            y,
+        )
+
+        xdiff = x[1] - x[0]
+        # if x is given width is based on the x scale and has to be converted to index
+        if width is not None:
+            width = width / xdiff
+
+        # same for distance
+        if distance is not None:
+            distance = distance / xdiff
+
+        # same for wlen
+        if wlen is not None:
+            wlen = wlen / xdiff
+
+        # same for plateau_size
+        if plateau_size is not None:
+            plateau_size = plateau_size / xdiff
+
     # Make a copy of the input array
-    y_array_copy = np.copy(y_array)
+    y_array_copy = np.copy(y)
 
     # Find the peaks in the copy of the input array
     peaks, _ = find_peaks(
@@ -235,8 +261,8 @@ def peak_finder(
         prominence=prominence,
         height=height,
         distance=distance,
-        width=width,
-        wlen=wlen,
+        width=max(1, width) if width is not None else None,
+        wlen=int(wlen) if wlen is not None else None,
         rel_height=rel_height,
         plateau_size=plateau_size,
     )
@@ -263,7 +289,7 @@ def peak_finder(
                 # Find the right minimum of the peak
                 right_min = mins[np.argmax(mins > peak)]
                 if right_min < peak:
-                    right_min = len(y_array) - 1
+                    right_min = len(y) - 1
 
                 try:
                     # Find the left minimum of the peak
@@ -289,7 +315,7 @@ def peak_finder(
             for peak in peaks:
                 right_min = mins[np.argmax(mins > peak)]
                 if right_min < peak:
-                    right_min = len(y_array) - 1
+                    right_min = len(y) - 1
                 try:
                     left_min = np.array(mins)[np.where(np.array(mins) < peak)][-1]
                 except IndexError:
@@ -307,7 +333,7 @@ def peak_finder(
 
     for peak_nr, peak in enumerate(peak_lst):
         peak_properties = compute_peak_properties(
-            x_array=x_array, y_array=y_array, peak_indices=peak, peak_nr=peak_nr
+            x_array=x, y_array=y, peak_indices=peak, peak_nr=peak_nr
         )
         peak_properties_list.append(peak_properties)
 
@@ -382,8 +408,8 @@ class BaselineModel(fn.DataEnum):
 
 @NodeDecorator(id="span.basics.fit", name="Fit 1D", separate_process=True)
 def fit_1D(
-    x_array: np.ndarray,
-    y_array: np.ndarray,
+    x: np.ndarray,
+    y: np.ndarray,
     basic_peaks: List[PeakProperties],
     main_model: FittingModel = FittingModel.Gaussian,
     baseline_model: BaselineModel = BaselineModel.Exponential,
@@ -408,15 +434,14 @@ def fit_1D(
 
     # """
 
-    x_array = np.array(x_array)
-    y_array = np.array(y_array)
+    x = np.array(x)
+    y = np.array(y)
 
     main_model = FittingModel.v(main_model)
 
     baseline_model = BaselineModel.v(baseline_model)
     peaks = copy.deepcopy(basic_peaks)
-    y = y_array
-    x = x_array
+
     # if is_sturated:
 
     lowest_index = min(dictionary.i_index for dictionary in peaks)
@@ -486,18 +511,20 @@ def fit_1D(
         best_values=out.best_values,
         data=out.data,
         userkws=out.userkws,
+        best_fit=out.best_fit,
+        rsquared=out.rsquared,
     )
 
     peak_properties_list = []
 
     for key in com.keys():
         if key != "baseline":
-            y_array = com[key]
-            peak_lst = [(0, np.argmax(y_array), len(y_array) - 1)]
+            y = com[key]
+            peak_lst = [(0, np.argmax(y), len(y) - 1)]
             for peak_nr, peak in enumerate(peak_lst):
                 peak_properties = compute_peak_properties(
-                    x_array=x_array,
-                    y_array=y_array,
+                    x_array=x,
+                    y_array=y,
                     peak_indices=peak,
                     peak_nr=peak_nr,
                     is_fitted=True,
@@ -516,7 +543,7 @@ def fit_1D(
 def force_peak_finder(
     x: np.array,
     y: np.array,
-    basic_peaks: List[PeakProperties],
+    basic_peaks: Union[List[PeakProperties], PeakProperties],
 ) -> List[PeakProperties]:
     # """
     # Identify and return the two peaks around the main peak in the given peaks dictionary.
@@ -531,10 +558,14 @@ def force_peak_finder(
     # Returns:
     # - dict: A dictionary containing information about the two identified peaks.
     # """
-    if len(basic_peaks) != 1:
-        raise ValueError("This method accepts one and only one main peak as an input.")
+    if isinstance(basic_peaks, (list, np.ndarray, tuple)):
+        if len(basic_peaks) != 1:
+            raise ValueError(
+                "This method accepts one and only one main peak as an input."
+            )
+        basic_peaks = basic_peaks[0]
 
-    peaks = copy.deepcopy(basic_peaks[0])
+    peaks = copy.deepcopy(basic_peaks)
     main_peak_i_index = peaks.i_index
     main_peak_r_index = peaks.index
     main_peak_f_index = peaks.f_index
@@ -566,7 +597,7 @@ def force_peak_finder(
     ):  # seond peak is in the leftside of the max peak #TODO: fix this
         common_point = max([num for num in max_pp if num < main_peak_r_index])
 
-        print("Left convoluted")
+        # print("Left convoluted")
         peak1 = {
             "I.Index": main_peak_i_index,
             "R.Index": max(
@@ -581,7 +612,7 @@ def force_peak_finder(
         }
     else:
         common_point = next((x for x in max_pp if x > main_peak_r_index), None)
-        print("Right convoluted")
+        # print("Right convoluted")
         peak1 = {
             "I.Index": main_peak_i_index,
             "R.Index": main_peak_r_index,
@@ -615,13 +646,11 @@ def force_peak_finder(
     default_render_options={"data": {"src": "figure"}},
     outputs=[{"name": "figure"}],
 )
-def plot_peaks(
-    x_array: np.array, y_array: np.array, peaks_dict: List[PeakProperties]
-) -> go.Figure:
+def plot_peaks(x: np.array, y: np.array, peaks_dict: List[PeakProperties]) -> go.Figure:
     fig = go.Figure()
 
     # Set up line plot
-    plot_trace = {"x": x_array, "y": y_array, "mode": "lines", "name": "data"}
+    plot_trace = {"x": x, "y": y, "mode": "lines", "name": "data"}
 
     fig.add_trace(go.Scatter(**plot_trace))
 
@@ -633,16 +662,16 @@ def plot_peaks(
         initial_idx = peak.i_index
         ending_idx = peak.f_index
         peak_height = peak.y_at_index
-        plot_y_min = min(y_array[initial_idx], y_array[ending_idx])
+        plot_y_min = min(y[initial_idx], y[ending_idx])
 
         # Create a scatter trace that simulates a rectangle
         fig.add_trace(
             go.Scatter(
                 x=[
-                    x_array[initial_idx],
-                    x_array[ending_idx],
-                    x_array[ending_idx],
-                    x_array[initial_idx],
+                    x[initial_idx],
+                    x[ending_idx],
+                    x[ending_idx],
+                    x[initial_idx],
                 ],
                 y=[plot_y_min, plot_y_min, peak_height, peak_height],
                 fill="toself",
@@ -689,10 +718,10 @@ def plot_fitted_peaks(peaks: List[PeakProperties]) -> go.Figure:
     if not peak._is_fitted:
         raise ValueError("No fitting information is available.")
 
-    x = peak.fitting_info["userkws"]["x"]
+    x = peak.fitting_info.userkws["x"]
     # Extract data from peaks
-    y = peak.fitting_info["data"]
-    best_fit = peak.fitting_info["best_fit"]
+    y = peak.fitting_info.data
+    best_fit = peak.fitting_info.best_fit
 
     # Create a subplot with 1 row, 1 column, and a secondary y-axis
     fig = make_subplots(specs=[[{"secondary_y": True}]])
@@ -741,8 +770,8 @@ def plot_fitted_peaks(peaks: List[PeakProperties]) -> go.Figure:
     fig.update_yaxes(title_text="Baseline corrected", secondary_y=True)
     fig.update_layout(
         title={
-            "text": f"{peak.fitting_info['model_name']} model with fitting "
-            f"score = {np.round(peak.fitting_info['rsquared'], 4)}",
+            "text": f"{peak.fitting_info.model_name} model with fitting "
+            f"score = {np.round(peak.fitting_info.rsquared, 4)}",
             "x": 0.5,  # Center the title
             "xanchor": "center",
         },

{funcnodes_span-0.2.1 → funcnodes_span-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-span"
-version = "0.2.1"
+version = "0.2.3"
 description = ""
 authors = ["Kourosh Rezaei <kouroshrezaei90@gmail.com>"]
 readme = "README.md"

funcnodes_span-0.2.1/funcnodes_span/normalization.py

@@ -1,54 +0,0 @@
-from funcnodes import NodeDecorator, Shelf
-import numpy as np
-
-import funcnodes as fn
-
-
-class NormMode(fn.DataEnum):
-    ZERO_ONE = "zero_one"
-    MINUS_ONE_ONE = "minus_one_one"
-    SUM_ABS = "sum_abs"
-    SUM = "sum"
-    EUCLIDEAN = "euclidean"
-    MEAN_STD = "mean_std"
-    MAX = "max"
-
-
-@NodeDecorator(id="span.basics.norm", name="Normalization node")
-def _norm(array: np.ndarray, mode: NormMode = NormMode.ZERO_ONE) -> np.ndarray:
-    # """
-    # Apply different normalizations to the array.
-
-    # Args:
-    #     array (np.ndarray): The input array to be normalized.
-    #     mode (NormMode): The normalization mode to apply. Defaults to NormMode.ZERO_ONE.
-
-    # Returns:
-    #     np.ndarray: The normalized array.
-
-    # Raises:
-    #     ValueError: If an unsupported normalization mode is provided.
-    # """
-    mode = NormMode.v(mode)
-    normalization_methods = {
-        NormMode.ZERO_ONE.value: lambda x: (x - np.amin(x)) / (np.amax(x) - np.amin(x)),
-        NormMode.MINUS_ONE_ONE.value: lambda x: 2
-        * ((x - np.amin(x)) / (np.amax(x) - np.amin(x)))
-        - 1,
-        NormMode.SUM_ABS.value: lambda x: x / np.abs(x).sum(),
-        NormMode.SUM.value: lambda x: x / x.sum(),
-        NormMode.EUCLIDEAN.value: lambda x: x / np.sqrt((x**2).sum()),
-        NormMode.MEAN_STD.value: lambda x: (x - x.mean()) / x.std(),
-        NormMode.MAX.value: lambda x: x / x.max(),
-    }
-    if mode not in normalization_methods.keys():
-        raise ValueError(f"Unsupported normalization mode: {mode}")
-    return normalization_methods[mode](array)
-
-
-NORM_NODE_SHELF = Shelf(
-    nodes=[_norm],
-    subshelves=[],
-    name="Normalization",
-    description="Normalization of the spectra",
-)