funcnodes-span 0.2.0__tar.gz → 0.2.2__tar.gz

{funcnodes_span-0.2.0 → funcnodes_span-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.2.0
+Version: 0.2.2
 Summary: 
 Home-page: https://linkdlab.de/
 Author: Kourosh Rezaei
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Numba
 Requires-Dist: funcnodes
-Requires-Dist: funcnodes-core (>=0.1.3)
+Requires-Dist: funcnodes-core (>=0.1.4)
 Requires-Dist: funcnodes_numpy
 Requires-Dist: funcnodes_pandas
 Requires-Dist: funcnodes_plotly

{funcnodes_span-0.2.0 → funcnodes_span-0.2.2}/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.0"
+__version__ = "0.2.2"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",

{funcnodes_span-0.2.0 → funcnodes_span-0.2.2}/funcnodes_span/baseline.py

@@ -1,20 +1,16 @@
+import funcnodes as fn
 from funcnodes import NodeDecorator, Shelf
 from exposedfunctionality import controlled_wrapper
 import numpy as np
-from enum import Enum
 from typing import Optional, Tuple, Union, List
 import pybaselines
 
 
-class CostFunction(Enum):
+class CostFunction(fn.DataEnum):
     asymmetric_indec = "asymmetric_indec"
     asymmetric_truncated_quadratic = "asymmetric_truncated_quadratic"
     asymmetric_huber = "asymmetric_huber"
 
-    @classmethod
-    def default(cls):
-        return cls.asymmetric_indec.value
-
 
 @NodeDecorator(
     "pybaselines.polynomial.goldindec",
@@ -33,7 +29,7 @@ def _goldindec(
     tol: float = 0.001,
     max_iter: int = 250,
     weights: Optional[np.ndarray] = None,
-    cost_function: CostFunction = CostFunction.default(),
+    cost_function: CostFunction = CostFunction.asymmetric_indec,
     peak_ratio: float = 0.5,
     alpha_factor: float = 0.99,
     tol_2: float = 0.001,
@@ -41,8 +37,7 @@ def _goldindec(
     max_iter_2: int = 100,
     return_coef: bool = False,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(cost_function, CostFunction):
-        cost_function = cost_function.value
+    cost_function = CostFunction.v(cost_function)
     baseline, params = pybaselines.polynomial.goldindec(
         data,
         x_data=x_data,
@@ -186,7 +181,7 @@ def _modpoly(
     return baseline_corrected, baseline, params
 
 
-class PenalizedPolyCostFunction(Enum):
+class PenalizedPolyCostFunction(fn.DataEnum):
     asymmetric_truncated_quadratic = "asymmetric_truncated_quadratic"
     symmetric_truncated_quadratic = "symmetric_truncated_quadratic"
     asymmetric_huber = "asymmetric_huber"
@@ -194,10 +189,6 @@ class PenalizedPolyCostFunction(Enum):
     asymmetric_indec = "asymmetric_indec"
     symmetric_indec = "symmetric_indec"
 
-    @classmethod
-    def default(cls):
-        return cls.asymmetric_truncated_quadratic.value
-
 
 @NodeDecorator(
     "pybaselines.polynomial.penalized_poly",
@@ -218,13 +209,12 @@ def _penalized_poly(
     max_iter: int = 250,
     tol: float = 1e-3,
     weights: Optional[np.ndarray] = None,
-    cost_function: PenalizedPolyCostFunction = PenalizedPolyCostFunction.default(),
+    cost_function: PenalizedPolyCostFunction = PenalizedPolyCostFunction.asymmetric_truncated_quadratic,
     threshold: Optional[float] = None,
     alpha_factor: float = 0.99,
     return_coef: bool = False,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(cost_function, PenalizedPolyCostFunction):
-        cost_function = cost_function.value
+    cost_function = PenalizedPolyCostFunction.v(cost_function)
     baseline, params = pybaselines.polynomial.penalized_poly(
         data,
         x_data=x_data,
@@ -1540,15 +1530,11 @@ def _noise_median(
     return baseline_corrected, baseline, params
 
 
-class Side(Enum):
+class Side(fn.DataEnum):
     both = "both"
     left = "left"
     right = "right"
 
-    @classmethod
-    def default(cls):
-        return cls.both.value
-
 
 @NodeDecorator(
     "pybaselines.smooth.ria",
@@ -1566,13 +1552,12 @@ def _ria(
     half_window: Optional[int] = None,
     max_iter: int = 500,
     tol: float = 0.01,
-    side: Side = Side.default(),
+    side: Side = Side.both,
     width_scale: float = 0.1,
     height_scale: float = 1.0,
     sigma_scale: float = 1.0 / 12.0,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(side, Side):
-        side = side.value
+    side = Side.v(side)
     baseline, params = pybaselines.smooth.ria(
         data,
         x_data=x_data,
@@ -1936,14 +1921,10 @@ CLASSIFICATION_NODE_SHELF = Shelf(
 )
 
 
-class Method(Enum):
+class Method(fn.DataEnum):
     modpoly = "modpoly"
     imodpoly = "imodpoly"
 
-    @classmethod
-    def default(cls):
-        return cls.modpoly.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.adaptive_minmax",
@@ -1961,14 +1942,13 @@ def _adaptive_minmax(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
     poly_order: Optional[Union[int, List[int]]] = None,
-    method: Method = Method.default(),
+    method: Method = Method.modpoly,
     constrained_fraction: Union[float, List[float]] = 0.01,
     constrained_weight: Union[float, List[float]] = 100000.0,
     estimation_poly_order: int = 2,
     weights: Optional[np.ndarray] = None,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, Method):
-        method = method.value
+    method = Method.v(method)
     baseline, params = pybaselines.optimizers.adaptive_minmax(
         data,
         x_data=x_data,
@@ -1983,7 +1963,7 @@ def _adaptive_minmax(
     return baseline_corrected, baseline, params
 
 
-class MethodColab(Enum):
+class MethodColab(fn.DataEnum):
     airpls = "airpls"
     arpls = "arpls"
     asls = "asls"
@@ -1994,10 +1974,6 @@ class MethodColab(Enum):
     iasls = "iasls"
     psalsa = "psalsa"
 
-    @classmethod
-    def default(cls):
-        return cls.asls.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.collab_pls",
@@ -2015,10 +1991,9 @@ def _collab_pls(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
     average_dataset: bool = True,
-    method: MethodColab = MethodColab.default(),
+    method: MethodColab = MethodColab.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodColab):
-        method = method.value
+    method = MethodColab.v(method)
     baseline, params = pybaselines.optimizers.collab_pls(
         data,
         x_data=x_data,
@@ -2029,7 +2004,7 @@ def _collab_pls(
     return baseline_corrected, baseline, params
 
 
-class MethodAll(Enum):
+class MethodAll(fn.DataEnum):
     goldindec = "goldindec"
     imodpoly = "imodpoly"
     loess = "loess"
@@ -2076,10 +2051,6 @@ class MethodAll(Enum):
     rubberband = "rubberband"
     std_distribution = "std_distribution"
 
-    @classmethod
-    def default(cls):
-        return cls.asls.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.custom_bc",
@@ -2097,10 +2068,9 @@ def _custom_bc(
     sampling: Union[int, np.ndarray] = 1,
     lam: Optional[float] = None,
     diff_order: int = 2,
-    method: MethodAll = MethodAll.default(),
+    method: MethodAll = MethodAll.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodAll):
-        method = method.value
+    method = MethodAll.v(method)
     baseline, params = pybaselines.optimizers.custom_bc(
         data,
         x_data=x_data,
@@ -2128,19 +2098,17 @@ def _custom_bc(
 def _optimize_extended_range(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
-    side: Side = Side.default(),
+    side: Side = Side.both,
     width_scale: float = 0.1,
     height_scale: float = 1.0,
     sigma_scale: float = 1.0 / 12.0,
     min_value: float = 2.0,
     max_value: float = 8.0,
     step: int = 1,
-    method: MethodAll = MethodAll.default(),
+    method: MethodAll = MethodAll.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodAll):
-        method = method.value
-    if isinstance(side, Side):
-        side = side.value
+    method = MethodAll.v(method)
+    side = Side.v(side)
     baseline, params = pybaselines.optimizers.optimize_extended_range(
         data,
         x_data=x_data,

funcnodes_span-0.2.2/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.0 → funcnodes_span-0.2.2}/funcnodes_span/peak_analysis.py

@@ -1,8 +1,8 @@
 from funcnodes import NodeDecorator, Shelf
+import funcnodes as fn
 import numpy as np
-from enum import Enum
 from exposedfunctionality import controlled_wrapper
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Dict
 from scipy.signal import find_peaks
 from scipy.stats import norm
 from scipy import signal, interpolate
@@ -13,6 +13,15 @@ import plotly.graph_objs as go
 from plotly.subplots import make_subplots
 import re
 from dataclasses import dataclass
+from .normalization import density_normalization
+
+
+@dataclass
+class FittinInfo:
+    model_name: str
+    best_values: dict
+    data: np.ndarray
+    userkws: dict
 
 
 @dataclass
@@ -35,8 +44,8 @@ class PeakProperties:
     width: float
     _is_fitted: bool = False
     _is_force_fitted: bool = False
-    fitting_data: Optional[dict] = None
-    fitting_info: Optional[dict] = None
+    fitting_data: Optional[Dict[str, np.ndarray]] = None
+    fitting_info: Optional[FittinInfo] = None
 
 
 def compute_peak_properties(
@@ -46,25 +55,27 @@ def compute_peak_properties(
     peak_nr: int,
     is_fitted: bool = False,
     is_force_fitted: bool = False,
-    fitting_data: Optional[dict] = None,
-    fitting_info: Optional[dict] = None,
+    fitting_data: Optional[Dict[str, np.ndarray]] = None,
+    fitting_info: Optional[FittinInfo] = None,
 ) -> PeakProperties:
-    # """
-    # Compute various properties of a given peak.
-
-    # Parameters:
-    # - x_array: np.ndarray - The array of x-values (e.g., time or wavelength).
-    # - y_array: np.ndarray - The array of y-values (e.g., intensity).
-    # - peak_indices: List[int] - A list containing the start index, peak index, and end index of the peak.
-    # - peak_nr: int - The identifier number of the peak.
-    # - is_fitted: bool = False - A flag indicating whether the peak is fitted or not.
-    # - is_force_fitted: bool = False - A flag indicating whether the peak is forced fitted or not.
-    # - fitting_data: Optional[dict] = None - A dictionary containing the fitting data if the peak is fitted.
-    # - fitting_info: Optional[dict] = None - A dictionary containing the fitting information if the peak is fitted.
-
-    # Returns:
-    # - peak_properties: PeakProperties - A dictionary containing various properties of the peak.
-    # """
+    """
+    Compute various properties of a given peak.
+
+    Parameters:
+    - x_array: np.ndarray - The array of x-values (e.g., time or wavelength).
+    - y_array: np.ndarray - The array of y-values (e.g., intensity).
+    - peak_indices: List[int] - A list containing the start index, peak index, and end index of the peak.
+    - peak_nr: int - The identifier number of the peak.
+    - is_fitted: bool = False - A flag indicating whether the peak is fitted or not.
+    - is_force_fitted: bool = False - A flag indicating whether the peak is forced fitted or not.
+    - fitting_data: Optional[Dict[str, np.ndarray]] = None - A dictionary containing the fitting
+        data if the peak is fitted.
+    - fitting_info: Optional[FittinInfo] = None - A dictionary containing the fitting information
+        if the peak is fitted.
+
+    Returns:
+    - peak_properties: PeakProperties - A dictionary containing various properties of the peak.
+    """
 
     i_index, index, f_index = peak_indices
 
@@ -198,7 +209,7 @@ def peak_finder(
     wlen: Optional[int] = None,
     rel_height: float = 0.5,
     plateau_size: Optional[int] = None,
-) -> dict:
+) -> List[PeakProperties]:
     peak_lst = []
     x_array = np.array(x_array, dtype=float)
     y_array = np.array(y_array, dtype=float)
@@ -208,13 +219,36 @@ def peak_finder(
     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
     noise_level = 5000 if noise_level is None else noise_level
 
+    if x_array is not None:
+        x_array, y_array = density_normalization(
+            x_array,
+            y_array,
+        )
+
+        xdiff = x_array[1] - x_array[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)
 
@@ -225,8 +259,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,
     )
@@ -331,7 +365,7 @@ def interpolation_1d(
     return x_interpolated, y_interpolated
 
 
-class FittingModel(Enum):
+class FittingModel(fn.DataEnum):
     ComplexConstant = "Complex Constant"
     Gaussian = "Gaussian"
     Gaussian2D = "Gaussian-2D"
@@ -356,12 +390,8 @@ class FittingModel(Enum):
     Rectangle = "Rectangle"
     Expression = "Expression"
 
-    @classmethod
-    def default(cls):
-        return cls.Gaussian.value
-
 
-class BaselineModel(Enum):
+class BaselineModel(fn.DataEnum):
     # Polynomial = "Polynomial"
     Linear = "Linear"
     Spline = "Spline"
@@ -374,13 +404,13 @@ class BaselineModel(Enum):
         return cls.Exponential.value
 
 
-@NodeDecorator(id="span.basics.fit", name="Fit 1D")
+@NodeDecorator(id="span.basics.fit", name="Fit 1D", separate_process=True)
 def fit_1D(
     x_array: np.ndarray,
     y_array: np.ndarray,
     basic_peaks: List[PeakProperties],
-    main_model: FittingModel = FittingModel.default(),
-    baseline_model: BaselineModel = BaselineModel.default(),
+    main_model: FittingModel = FittingModel.Gaussian,
+    baseline_model: BaselineModel = BaselineModel.Exponential,
 ) -> List[PeakProperties]:
     # """
     # Fit a 1D model to the given data.
@@ -405,10 +435,9 @@ def fit_1D(
     x_array = np.array(x_array)
     y_array = np.array(y_array)
 
-    if isinstance(main_model, FittingModel):
-        main_model = main_model.value
-    if isinstance(baseline_model, BaselineModel):
-        baseline_model = baseline_model.value
+    main_model = FittingModel.v(main_model)
+
+    baseline_model = BaselineModel.v(baseline_model)
     peaks = copy.deepcopy(basic_peaks)
     y = y_array
     x = x_array
@@ -473,8 +502,15 @@ def fit_1D(
 
     out = f.fit(y, pars, x=x)
     com = out.eval_components(x=x)
-    info_dict = out.__dict__
-    info_dict["model_name"] = main_model
+    # info_dict = out.__dict__
+    # info_dict["model_name"] = main_model
+
+    info_dict = FittinInfo(
+        model_name=main_model,
+        best_values=out.best_values,
+        data=out.data,
+        userkws=out.userkws,
+    )
 
     peak_properties_list = []
 

{funcnodes_span-0.2.0 → funcnodes_span-0.2.2}/funcnodes_span/smoothing.py

@@ -1,28 +1,70 @@
+from typing import Dict, Callable
 from funcnodes import NodeDecorator, Shelf
 import numpy as np
 import pandas as pd
-from enum import Enum
 from scipy.signal import savgol_filter, medfilt
 from scipy.ndimage import gaussian_filter1d
 import warnings
+import funcnodes as fn
 
 warnings.filterwarnings("ignore")
 
-class SmoothMode(Enum):
+
+class SmoothMode(fn.DataEnum):
     SAVITZKY_GOLAY = "savgol"
     GAUSSIAN = "gaussian"
     MOVING_AVERAGE = "ma"
     EXPONENTIAL_MOVING_AVERAGE = "ema"
     MEDIAN = "median"
-    
-    @classmethod
-    def default(cls) -> 'SmoothMode':
-        """Returns the default smoothing mode."""
-        return cls.SAVITZKY_GOLAY.value
 
-@NodeDecorator("span.basics.smooth", name="Smoothing")
 
-def _smooth(array: np.ndarray, mode: SmoothMode = SmoothMode.default(), window: int = 5) -> np.ndarray:
+def smooth_savgol(x: np.ndarray, window: int) -> np.ndarray:
+    return savgol_filter(x, window, 2)
+
+
+def smooth_gaussian(x: np.ndarray, window: int) -> np.ndarray:
+    return gaussian_filter1d(x, window)
+
+
+def smooth_ma(x: np.ndarray, window: int) -> np.ndarray:
+    if x.ndim > 1:
+        n, m = x.shape
+        result = np.zeros((n, m))
+        for i in range(n):
+            result[i, :] = np.convolve(x[i, :], np.ones(window) / window, mode="same")
+        return result
+    else:
+        return np.convolve(x, np.ones(window) / window, mode="same")
+
+
+def smooth_ema(x: np.ndarray, window: int) -> np.ndarray:
+    if x.ndim > 1:
+        n, m = x.shape
+        result = np.zeros((n, m))
+        for i in range(n):
+            result[i, :] = pd.Series(x[i, :]).ewm(span=window).mean().values
+        return result
+    else:
+        return pd.Series(x).ewm(span=window).mean().values
+
+
+def smooth_median(x: np.ndarray, window: int) -> np.ndarray:
+    return medfilt(x, window)
+
+
+_SMOOTHING_MAPPER: Dict[str, Callable[[np.ndarray, int], np.ndarray]] = {
+    SmoothMode.SAVITZKY_GOLAY.value: smooth_savgol,
+    SmoothMode.GAUSSIAN.value: smooth_gaussian,
+    SmoothMode.MOVING_AVERAGE.value: smooth_ma,
+    SmoothMode.EXPONENTIAL_MOVING_AVERAGE.value: smooth_ema,
+    SmoothMode.MEDIAN.value: smooth_median,
+}
+
+
+@NodeDecorator("span.basics.smooth", name="Smoothing")
+def _smooth(
+    array: np.ndarray, mode: SmoothMode = SmoothMode.SAVITZKY_GOLAY, window: int = 5
+) -> np.ndarray:
     # """
     # Apply different smoothing techniques to the input array.
 
@@ -37,49 +79,12 @@ def _smooth(array: np.ndarray, mode: SmoothMode = SmoothMode.default(), window:
     # Raises:
     #     ValueError: If an unsupported smoothing mode is provided.
     # """
-    if isinstance(mode, SmoothMode):
-        mode = mode.value
-    def smooth_savgol(x: np.ndarray) -> np.ndarray:
-        return savgol_filter(x, window, 2)
-    
-    def smooth_gaussian(x: np.ndarray) -> np.ndarray:
-        return gaussian_filter1d(x, window)
-    
-    def smooth_ma(x: np.ndarray) -> np.ndarray:
-        if x.ndim > 1:
-            n, m = x.shape
-            result = np.zeros((n, m))
-            for i in range(n):
-                result[i, :] = np.convolve(x[i, :], np.ones(window) / window, mode="same")
-            return result
-        else:
-            return np.convolve(x, np.ones(window) / window, mode="same")
-    
-    def smooth_ema(x: np.ndarray) -> np.ndarray:
-        if x.ndim > 1:
-            n, m = x.shape
-            result = np.zeros((n, m))
-            for i in range(n):
-                result[i, :] = pd.Series(x[i, :]).ewm(span=window).mean().values
-            return result
-        else:
-            return pd.Series(x).ewm(span=window).mean().values
-    
-    def smooth_median(x: np.ndarray) -> np.ndarray:
-        return medfilt(x, window)
-    
-    smoothing_methods = {
-        SmoothMode.SAVITZKY_GOLAY.value: smooth_savgol,
-        SmoothMode.GAUSSIAN.value: smooth_gaussian,
-        SmoothMode.MOVING_AVERAGE.value: smooth_ma,
-        SmoothMode.EXPONENTIAL_MOVING_AVERAGE.value: smooth_ema,
-        SmoothMode.MEDIAN.value: smooth_median
-    }
-    
-    if mode not in smoothing_methods.keys():
+    mode = SmoothMode.v(mode)
+
+    if mode not in _SMOOTHING_MAPPER.keys():
         raise ValueError(f"Unsupported smoothing mode: {mode}")
-    
-    return smoothing_methods[mode](array)
+
+    return _SMOOTHING_MAPPER[mode](array, window)
 
 
 # @NodeDecorator("span.basics.smooth.savgol", name="Savgol")
@@ -187,4 +192,4 @@ SMOOTH_NODE_SHELF = Shelf(
     subshelves=[],
     name="Smoothing",
     description="Smoothing of the spectra",
-)
+)

{funcnodes_span-0.2.0 → funcnodes_span-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-span"
-version = "0.2.0"
+version = "0.2.2"
 description = ""
 authors = ["Kourosh Rezaei <kouroshrezaei90@gmail.com>"]
 readme = "README.md"
@@ -15,7 +15,7 @@ funcnodes_numpy = "*"
 funcnodes_pandas = "*"
 funcnodes_plotly = "*"
 
-funcnodes-core = ">=0.1.3"
+funcnodes-core = ">=0.1.4"
 pybaselines = "*"
 Numba = "*"
 pentapy = "*"

funcnodes_span-0.2.0/funcnodes_span/normalization.py

@@ -1,56 +0,0 @@
-from funcnodes import NodeDecorator, Shelf
-import numpy as np
-from enum import Enum
-
-
-class NormMode(Enum):
-    ZERO_ONE = "zero_one"
-    MINUS_ONE_ONE = "minus_one_one"
-    SUM_ABS = "sum_abs"
-    SUM = "sum"
-    EUCLIDEAN = "euclidean"
-    MEAN_STD = "mean_std"
-    MAX = "max"
-
-    @classmethod
-    def default(cls) -> "NormMode":
-        """Returns the default normalization mode."""
-        return cls.ZERO_ONE.value
-
-
-@NodeDecorator(id="span.basics.norm", name="Normalization node")
-def _norm(array: np.ndarray, mode: NormMode = NormMode.default()) -> 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.
-    # """
-    if isinstance(mode, NormMode):
-        mode = mode.value
-    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",
-)