chemotools 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

chemotools/baseline/__init__.py

@@ -2,4 +2,5 @@ from .air_pls import AirPls
 from .cubic_spline_correction import CubicSplineCorrection
 from .linear_correction import LinearCorrection
 from .non_negative import NonNegative
-from .polynomial_correction import PolynomialCorrection
+from .polynomial_correction import PolynomialCorrection
+from .subtract_reference import SubtractReference

chemotools/baseline/cubic_spline_correction.py

@@ -6,10 +6,10 @@ from sklearn.utils.validation import check_is_fitted
 from chemotools.utils.check_inputs import check_input
 
 class CubicSplineCorrection(BaseEstimator, TransformerMixin):
-    def __init__(self, indices: tuple = None) -> None:
+    def __init__(self, indices: np.ndarray = None) -> None:
         self.indices = indices
 
-    def fit(self, X: np.ndarray, y=None) -> "CubicSplineCorrection":
+    def fit(self, X: list, y=None) -> "CubicSplineCorrection":
         # Check that X is a 2D array and has only finite values
         X = check_input(X)
 
@@ -19,6 +19,11 @@ class CubicSplineCorrection(BaseEstimator, TransformerMixin):
         # Set the fitted attribute to True
         self._is_fitted = True
 
+        if self.indices is None:
+            self.indices_ = [0, len(X[0]) - 1]
+        else:
+            self.indices_ = self.indices
+
         return self
 
     def transform(self, X: np.ndarray, y=None, copy=True):
@@ -39,11 +44,7 @@ class CubicSplineCorrection(BaseEstimator, TransformerMixin):
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
     def _spline_baseline_correct(self, x: np.ndarray) -> np.ndarray:
-        if self.indices is None:
-            indices = [0, len(x) - 1]
-        else:
-            indices = list(self.indices)
-
+        indices = self.indices_
         intensity = x[indices]  
         spl = CubicSpline(indices, intensity)
         baseline = spl(range(len(x)))      

chemotools/baseline/polynomial_correction.py

@@ -5,7 +5,7 @@ from sklearn.utils.validation import check_is_fitted
 from chemotools.utils.check_inputs import check_input
 
 class PolynomialCorrection(BaseEstimator, TransformerMixin):
-    def __init__(self, order: int = 1, indices: tuple = (0, -1)) -> None:
+    def __init__(self, order: int = 1, indices: list = None) -> None:
         self.order = order
         self.indices = indices
 
@@ -19,6 +19,11 @@ class PolynomialCorrection(BaseEstimator, TransformerMixin):
         # Set the fitted attribute to True
         self._is_fitted = True
 
+        if self.indices is None:
+            self.indices_ = range(0, len(X[0]))
+        else:
+            self.indices_ = self.indices
+
         return self
     
     def transform(self, X: np.ndarray, y=0, copy=True) -> np.ndarray:
@@ -39,7 +44,7 @@ class PolynomialCorrection(BaseEstimator, TransformerMixin):
         return X_.reshape(-1, 1) if X_.ndim == 1 else X_
     
     def _baseline_correct_spectrum(self, x: np.ndarray) -> np.ndarray:
-        intensity = x[list(self.indices)]
-        poly = np.polyfit(self.indices, intensity, self.order)
+        intensity = x[self.indices_]
+        poly = np.polyfit(self.indices_, intensity, self.order)
         baseline = [np.polyval(poly, i) for i in range(0, len(x))]      
         return x - baseline

chemotools/baseline/subtract_reference.py

@@ -0,0 +1,54 @@
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_is_fitted
+
+from chemotools.utils.check_inputs import check_input
+
+
+class SubtractReference(BaseEstimator, TransformerMixin):
+    def __init__(
+        self,
+        reference: np.ndarray = None,
+    ):
+        self.reference = reference
+
+    def fit(self, X: np.ndarray, y=None) -> "SubtractReference":
+        # Check that X is a 2D array and has only finite values
+        X = check_input(X)
+
+        # Set the number of features
+        self.n_features_in_ = X.shape[1]
+
+        # Set the fitted attribute to True
+        self._is_fitted = True
+
+        # Set the reference
+
+        if self.reference is not None:
+            self.reference_ = self.reference.copy()
+            return self
+        
+        return self
+
+    def transform(self, X: np.ndarray, y=None) -> np.ndarray:
+        # Check that the estimator is fitted
+        check_is_fitted(self, "_is_fitted")
+
+        # Check that X is a 2D array and has only finite values
+        X = check_input(X)
+        X_ = X.copy()
+
+        # Check that the number of features is the same as the fitted data
+        if X_.shape[1] != self.n_features_in_:
+            raise ValueError(f"Expected {self.n_features_in_} features but got {X_.shape[1]}")
+
+        if self.reference is None:
+            return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+
+        # Subtract the reference
+        for i, x in enumerate(X_):
+            X_[i] = self._subtract_reference(x)
+        return X_.reshape(-1, 1) if X_.ndim == 1 else X_
+
+    def _subtract_reference(self, x) -> np.ndarray:
+        return x - self.reference_

chemotools/derivative/norris_william.py

@@ -50,7 +50,7 @@ class NorrisWilliams(BaseEstimator, TransformerMixin):
                 X_[i] = derivative
             return X_.reshape(-1, 1) if X_.ndim == 1 else X_
 
-        if self.derivative_order == 1:
+        if self.derivative_order == 2:
             for i, x in enumerate(X_):
                 derivative = self._spectrum_second_derivative(x)
                 X_[i] = derivative

chemotools-0.0.12.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.1
+Name: chemotools
+Version: 0.0.12
+Summary: Package to integrate chemometrics in scikit-learn pipelines
+Home-page: https://github.com/paucablop/chemotools
+Author: Pau Cabaneros Lopez
+Author-email: pau.cabaneros@gmail.com
+Project-URL: Bug Tracker, https://github.com/paucablop/chemotools/issues/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+
+[![pypi](https://img.shields.io/pypi/v/chemotools)](https://pypi.org/project/chemotools)
+[![pypi](https://img.shields.io/pypi/pyversions/chemotools)](https://pypi.org/project/chemotools)
+[![pypi](https://img.shields.io/pypi/l/chemotools)](https://github.com/paucablop/chemotools/blob/main/LICENSE)
+[![codecov](https://codecov.io/github/paucablop/chemotools/branch/main/graph/badge.svg?token=D7JUJM89LN)](https://codecov.io/github/paucablop/chemotools)
+
+# __chemotools__
+
+Welcome to Chemotools, a Python package that integrates chemometrics with Scikit-learn.
+
+👉 Check the [documentation](https://paucablop.github.io/chemotools/) for a full description on how to use chemotools.
+
+## Description
+
+Chemotools is a Python package that provides a collection of preprocessing tools and utilities for working with spectral data. It is built on top of popular scientific libraries and is designed to be highly modular, easy to use, and compatible with Scikit-learn transformers.
+
+If you are interested in learning more about chemotools, please visit the [documentation](https://paucablop.github.io/chemotools/) page.
+
+Benefits:
+- Provides a collection of preprocessing tools and utilities for working with spectral data
+- Highly modular and compatible with Scikit-learn transformers
+- Can perform popular preprocessing tasks such as baseline correction, smoothing, scaling, derivatization, and scattering correction
+- Open source and available on PyPI
+
+Applications:
+- Analyzing and processing spectral data in chemistry, biology, and other fields
+- Developing machine learning models for predicting properties or classifying samples based on spectral data
+- Teaching and learning about chemometrics and data preprocessing in Python
+
+## Installation
+
+Chemotools is distributed via PyPI and can be easily installed using pip:
+
+```bash
+pip install chemotools
+```
+
+## Usage
+
+Chemotools is designed to be used in conjunction with Scikit-learn. It follows the same API as other Scikit-learn transformers, so you can easily integrate it into your existing workflow. For example, you can use chemotools to build pipelines that include transformers from chemotools and Scikit-learn:
+
+```python
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import make_pipeline
+
+from chemotools.baseline import AirPls
+from chemotools.scatter import MultiplicativeScatterCorrection
+
+preprocessing = make_pipeline(AirPls(), MultiplicativeScatterCorrection(), StandardScaler(with_std=False)) 
+spectra_transformed = preprocessing.fit_transform(spectra)
+```
+
+Check the [documentation](https://paucablop.github.io/chemotools/) for more information on how to use chemotools.
+
+
+## Contributing
+
+We welcome contributions to Chemotools from anyone interested in improving the package. Whether you have ideas for new features, bug reports, or just want to help improve the code, we appreciate your contributions! You are also welcome to see the [Project Board](https://github.com/users/paucablop/projects/4) to see what we are currently working on.
+
+To contribute to Chemotools, please follow these guidelines:
+
+#### Reporting Bugs
+
+If you encounter a bug or unexpected behavior in Chemotools, please open an issue on the GitHub repository with a detailed description of the problem, including any error messages and steps to reproduce the issue. If possible, include sample code or data that demonstrates the problem.
+
+#### Suggesting Enhancements
+
+If you have an idea for a new feature or enhancement for Chemotools, please open an issue on the GitHub repository with a detailed description of the proposed feature and its benefits. If possible, include example code or use cases that illustrate how the feature would be used.
+
+#### Submitting Changes
+
+If you'd like to contribute code changes to Chemotools, please follow these steps:
+
+- Create a new branch for your changes. We follow trunk-based development, so all changes should be made on a new branch and branches should be short-lived and merged into main.
+
+- Write your code and tests, making sure to follow the Chemotools coding style and conventions. It is fundamental to include tests for both, the Scikit-learn API and the functionality of the transformers.
+
+- Run the tests using the provided testing framework to ensure that your changes do not introduce any new errors or regressions.
+
+- Submit a pull request to the main Chemotools repository with a detailed description of your changes and the problem they solve.
+
+We will review your changes and provide feedback as soon as possible. If we request changes, please make them as quickly as possible to keep the review process moving.
+
+#### Code Style
+
+Please follow the Chemotools code style and conventions when contributing code changes. Specifically:
+
+- Use four spaces for indentation
+- Use descriptive variable names
+- Avoid using magic numbers or hard-coded strings
+- Format your code using Black
+
+#### Codecov
+
+We use Codecov to track the test coverage of Chemotools. Please make sure that your changes do not reduce the test coverage of the package.
+
+
+## License
+
+This package is distributed under the MIT license. See the [LICENSE](LICENSE) file for more information. When contributing code to Chemotools, you are agreeing to release your code under the MIT license.
+
+## Credits
+
+AirPLS baseline correction is based on the implementation by [Zhang et al.](https://pubs.rsc.org/is/content/articlelanding/2010/an/b922045c). The current implementation is based on the Python implementation by [zmzhang](https://github.com/zmzhang/airPLS).

{chemotools-0.0.10.dist-info → chemotools-0.0.12.dist-info}/RECORD

@@ -1,12 +1,13 @@
 chemotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chemotools/baseline/__init__.py,sha256=DVdmkXqKfrDUcwNOO6xXELmyPwHQza8_lzAIGDKKZdg,228
+chemotools/baseline/__init__.py,sha256=8KVAXB4OwGPH-lan5NOwqdqyr08kJW9qDegJlzd9cO8,278
 chemotools/baseline/air_pls.py,sha256=34t-APOEPpDTSdkAYq41xJ9Qt_OBDlKSPgnItoqTB6g,2568
-chemotools/baseline/cubic_spline_correction.py,sha256=oFnPhbCQT9y5SJMSOeUOQ2vnBlkgQJ1AFwHDvAjKrUU,1732
+chemotools/baseline/cubic_spline_correction.py,sha256=QkPvjoivA3O61zBUrt7Ro98_HidgtQMvxSe6GYCfJ7U,1772
 chemotools/baseline/linear_correction.py,sha256=2NXW_tiXNK9ZL-At2opTLmDhAxjFF0J9bXnWDqDjNYY,1900
 chemotools/baseline/non_negative.py,sha256=1L8wE0JUsQWmdku-Sm73ubDiIZ72CtImSvInQMPC-rU,1427
-chemotools/baseline/polynomial_correction.py,sha256=cLOhc7J0ERVi7wcXLLvjDaoCpZs-ADzF47iDpqhbgQc,1689
+chemotools/baseline/polynomial_correction.py,sha256=PtoR6T_rdk7ygJt4JsbR1qNOI4cP8Ntmq3ocKUet6Qo,1818
+chemotools/baseline/subtract_reference.py,sha256=jDLKpYQqGFEPcwkNTwzAOzw2tNSkRdubdmz6yJOkT7U,1684
 chemotools/derivative/__init__.py,sha256=x2F0IJ-uCbEYFoXFbZl_RTPCbSq82vqGOwlM9R_2Klo,84
-chemotools/derivative/norris_william.py,sha256=CqqCL41xs0mZ5OlJ06iYPzpnb8bJKAfmh81PAe43vmw,3134
+chemotools/derivative/norris_william.py,sha256=kREo1JYBZrM9pZ9HXVoU4nTndZKP2MbjGomX7KIxFTI,3134
 chemotools/derivative/savitzky_golay.py,sha256=FO65XpgbY1QNC7nPsLJVmmrx5gurGKpqIAH2NnjSWrk,1801
 chemotools/scale/__init__.py,sha256=Lr8fVyaBjFMf1cjDAI-a_gCrXivKCpyTOYnuJZHRh98,79
 chemotools/scale/l_normalize.py,sha256=Z_CtUfCJoVsn8CasVzZUjIzs02QzxLwFg2zqmXN3cWQ,1349
@@ -24,10 +25,10 @@ chemotools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 chemotools/utils/check_inputs.py,sha256=fRAV4HIaGamdj_PNXSNnl7LurXytACNTGO51rhPpMUY,512
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/fixtures.py,sha256=TxsGOMszSMnttUO4iWniNKeiXEkjRzhlPU9aLeyT89s,1505
-tests/test_functionality.py,sha256=KLeRTJrgDqmp4f1bQohJSqFCgy_WqTPNENZal6qN7dY,6803
-tests/test_sklearn_compliance.py,sha256=VIsCkPtL2U9EisiwhpMAnZsUXDDlfkCxPuhx14JjDi0,2907
-chemotools-0.0.10.dist-info/LICENSE,sha256=qtyOy2wDQVX9hxp58h3T-6Lmfv-mSCHoSRkcLUdM9bg,1070
-chemotools-0.0.10.dist-info/METADATA,sha256=NntaneHjPpPxaRpEU0YPCmJNYDkwyaY6fnafqbBHavA,18720
-chemotools-0.0.10.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-chemotools-0.0.10.dist-info/top_level.txt,sha256=eNcNcKSdo-1H_2gwSDrS__dr7BM3R73Cnn-pBiW5FEw,17
-chemotools-0.0.10.dist-info/RECORD,,
+tests/test_functionality.py,sha256=J5yqA29E7WU0AvieFP6wFLCUH783udVZ-XrnErrBT5Y,7351
+tests/test_sklearn_compliance.py,sha256=_a8gazkjJtj9STrt6fwvC37wFviZhpz-KCt3_LnmG_w,3309
+chemotools-0.0.12.dist-info/LICENSE,sha256=qtyOy2wDQVX9hxp58h3T-6Lmfv-mSCHoSRkcLUdM9bg,1070
+chemotools-0.0.12.dist-info/METADATA,sha256=NO-f_BJeOX4l2rMXu_Nu8ZI3my-HlWSpeMboiB5FFM4,6165
+chemotools-0.0.12.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+chemotools-0.0.12.dist-info/top_level.txt,sha256=eNcNcKSdo-1H_2gwSDrS__dr7BM3R73Cnn-pBiW5FEw,17
+chemotools-0.0.12.dist-info/RECORD,,

tests/test_functionality.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from chemotools.baseline import AirPls, LinearCorrection, NonNegative
+from chemotools.baseline import AirPls, LinearCorrection, NonNegative, SubtractReference
 from chemotools.derivative import NorrisWilliams, SavitzkyGolay
 from chemotools.scale import LNormalize, MinMaxScaler
 from chemotools.scatter import MultiplicativeScatterCorrection, StandardNormalVariate
@@ -238,6 +238,7 @@ def test_saviszky_golay_filter_3():
     # Assert
     assert np.allclose(spectrum_corrected[0], np.ones((1, 10)), atol=1e-2)
 
+
 def test_standard_normal_variate(spectrum, reference_snv):
     # Arrange
     snv = StandardNormalVariate()
@@ -248,6 +249,25 @@ def test_standard_normal_variate(spectrum, reference_snv):
     # Assert
     assert np.allclose(spectrum_corrected[0], reference_snv[0], atol=1e-2)
 
+def test_subtract_reference(spectrum):
+    # Arrange
+    baseline = SubtractReference(reference=spectrum)
+
+    # Act
+    spectrum_corrected = baseline.fit_transform(spectrum)
+
+    # Assert
+    assert np.allclose(spectrum_corrected[0], np.zeros(len(spectrum)), atol=1e-8)
+
+def test_subtract_reference_without_reference(spectrum):
+    # Arrange
+    baseline = SubtractReference()
+
+    # Act
+    spectrum_corrected = baseline.fit_transform(spectrum)
+
+    # Assert
+    assert np.allclose(spectrum_corrected[0], spectrum, atol=1e-8)
 
 def test_whitakker_smooth(spectrum, reference_whitakker):
     # Arrange

tests/test_sklearn_compliance.py

@@ -1,11 +1,13 @@
 from sklearn.utils.estimator_checks import check_estimator
 
-from chemotools.baseline import AirPls, CubicSplineCorrection, LinearCorrection, NonNegative, PolynomialCorrection
+from chemotools.baseline import AirPls, CubicSplineCorrection, LinearCorrection, NonNegative, PolynomialCorrection, SubtractReference
 from chemotools.derivative import NorrisWilliams, SavitzkyGolay
 from chemotools.scale import MinMaxScaler, LNormalize
 from chemotools.scatter import MultiplicativeScatterCorrection, StandardNormalVariate
 from chemotools.smooth import MeanFilter, MedianFilter, SavitzkyGolayFilter, WhittakerSmooth
 
+from tests.fixtures import spectrum
+
 
 # AirPls
 def test_compliance_air_pls():
@@ -77,6 +79,14 @@ def test_compliance_norris_williams():
     # Act & Assert
     check_estimator(transformer)
 
+# NorrisWilliams
+def test_compliance_norris_williams_2():
+    # Arrange
+    transformer = NorrisWilliams(derivative_order=2)
+    # Act & Assert
+    check_estimator(transformer)
+
+
 # PolynomialCorrection
 def test_compliance_polynomial_correction():
     # Arrange
@@ -105,6 +115,13 @@ def test_compliance_standard_normal_variate():
     # Act & Assert
     check_estimator(transformer)
 
+# SubtractReference
+def test_compliance_subtract_reference():
+    # Arrange
+    transformer = SubtractReference()
+    # Act & Assert
+    check_estimator(transformer)
+
 # WhittakerSmooth
 def test_compliance_whittaker_smooth():
     # Arrange

chemotools-0.0.10.dist-info/METADATA

@@ -1,411 +0,0 @@
-Metadata-Version: 2.1
-Name: chemotools
-Version: 0.0.10
-Summary: Package to integrate chemometrics in scikit-learn pipelines
-Home-page: https://github.com/paucablop/chemotools
-Author: Pau Cabaneros Lopez
-Author-email: pau.cabaneros@gmail.com
-Project-URL: Bug Tracker, https://github.com/paucablop/chemotools/issues/
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-
-## Welcome to chemotools! 🖖 
-
-This project is an implementation of spectral preprocessing techniques integrated with the widely popular sklearn API, providing you with an easy-to-use toolkit for analyzing and manipulating your data. With this integration, you can easily apply techniques such as spectral derivative, scatter correction or baseline removal to your datasets.
-
-The goal of this project is to provide a comprehensive and user-friendly package for spectral preprocessing, with a focus on making it accessible to a wide range of users, from data scientists to researchers to curious learners. By integrating these techniques with the powerful sklearn API, I enable users to easily build machine learning and chemometric models on top of preprocessed data, making it possible to identify patterns and make predictions with greater accuracy.
-
-In this repository, you will find a range of tools and resources for using spectral preprocessing techniques with the sklearn API, including code samples, documentation, and examples. I encourage contributions from the community, whether through bug reports, feature requests, or pull requests, to help us make this project even better.
-
-In addition, I take great care to ensure that all functions are thoroughly unit tested for both API compatibility and functionality. I believe that unit testing is an essential part of any software development process, and it is particularly important for a project like this, which aims to provide reliable data analysis tools. I hope that this project will serve as a useful resource for anyone interested in learning more about spectral preprocessing and machine learning.
-
-Thank you for your interest in this project, and I hope you find it useful for your data analysis and machine learning needs.
-
-Table of contents
-=================
-
-<!--ts-->
-   * [Installation](#installation)
-   * [Integration with scikit-learn](#integration-with-scikit-learn)
-   * [Scatter](#scatter)
-        * [Multiplicative scatter correction](#multiplicative-scatter-correction)
-        * [Standard normal variate](#standard-normal-variate)
-        * [Extended multiplicative scatter correction (COMING SOON)](#extended-multiplicative-scatter-correction)
-   * [Derivative](#derivatives)
-        * [Savitzky-Golay derivative](#savitzky-golay-derivative)
-        * [William Norris derivative](#william-norris-derivative)
-   * [Baseline](#baseline)
-        * [Linear baseline correction](#linear-baseline-correction)
-        * [Polynomial baseline correction](#polynomial-baseline-correction)
-        * [Cubic spline baseline correction](#cubic-spline-baseline-correction)
-        * [AirPls](#alternate-iterative-reweighed-penalized-least-squares-(AIRPLS)-baseline-correction)
-        * [Non-negative](#non-negative)
-   * [Scale](#scale)
-        * [Min-max scaler](#minmax-scaler)
-        * [L-Norm scaler](#l-norm-scaler)
-   * [Smooth](#smooth)
-        * [Savitzky-Golay smoothing](#savitzky-golay-smoothing)
-        * [Whittaker smoother](#whittaker-smoother)
-        * [Mean filter](#mean-filter)
-        * [Median filter](#median-filter)
-
-<!--te-->
-
-
-## __Installation 🚀__
-This package is available on PyPI and can be installed using pip:
-
-```bash
-pip install chemotools
-```
-
-## __Integration with scikit-learn ✨__
-All preprocessing techniques in this package are compatible with ```scikit-learn``` and can be used in pipelines. For example, the following code creates a pipeline that performs multiplicative scatter correction, followed by a min-max scaling and a Savitzky-Golay smoothing:
-
-```python
-from sklearn.preprocessing import StandardScaler
-from sklearn.pipeline import make_pipeline
-
-pipeline = make_pipeline(AirPls(), MultiplicativeScatterCorrection(), StandardScaler(with_std=False)) 
-spectra_transformed = pipeline.fit_transform(spectra)
-```
-
-
-## __Scatter__
-
-This package contains three common algorithms for scatter correction in spectroscopy:
-
-- Multiplicative scatter correction (MSC)
-- Standard normal variate (SNV)
-- Extended multiplicative scatter correction (EMSC)
-
-### __Multiplicative scatter correction__
-Multiplicative scatter correction (MSC) is a preprocessing technique in spectroscopy that corrects for the influence of light scattering on spectral measurements by dividing each spectrum by a scatter reference spectrum. The current implementation, accepts three types of reference spectra:
-
-- The mean spectrum of the dataset (_default_).
-- The median spectrum of the dataset.
-- A single spectrum that is used to correct all spectra in the dataset.
-
-Usage example for a single reference spectrum:
-
-Usage example for the mean spectrum:
-
-```python
-from chemotools.scatter import MultiplicativeScatterCorrection
-
-msc = MultiplicativeScatterCorrection()
-spectra_msc = msc.fit_transform(spectra)
-``` 
-
-Usage example for the median spectrum:
-
-```python
-from chemotools.scatter import MultiplicativeScatterCorrection
-
-msc = MultiplicativeScatterCorrection(use_median=True)
-spectra_msc = msc.fit_transform(spectra)
-``` 
-
-Usage example for a single reference spectrum:
-
-```python
-from chemotools.scatter import MultiplicativeScatterCorrection
-
-msc = MultiplicativeScatterCorrection(reference=reference_spectrum)
-spectra_msc = msc.fit_transform(spectra)
-```
-
-![msc](figures/msc.png)
-
-
-### __Standard normal variate__
-Standard normal variate (SNV) is a preprocessing technique in spectroscopy that adjusts for baseline shifts and variations in signal intensity by subtracting the mean and dividing by the standard deviation of each spectrum.
-
-Usage example for a single reference spectrum:
-
-```python
-from chemotools.scatter import StandardNormalVariate
-
-snv = StandardNormalVariate()
-spectra_snv = snv.fit_transform(spectra)
-```
-![snv](figures/snv.png)
-
-
-### __Extended multiplicative scatter correction__
-Extended multiplicative scatter correction (EMSC) is a preprocessing technique in spectroscopy that corrects for the influence of light scattering and instrumental drift by fitting a mathematical model to a reference spectrum and using it to normalize all spectra in the dataset.
-
-An implementation of the EMSC will be available soon 🤓.
-
-## __Derivatives__
-
-This package contains two common algorithms for calculating derivatives in spectroscopy:
-
-- Savitzky-Golay derivative
-- William Norris derivative
-
-### __Savitzky-Golay derivative__
-Savitzky-Golay derivative is a preprocessing technique in spectroscopy that calculates the derivative of a spectrum by fitting a polynomial to a window of adjacent points and calculating the derivative of the polynomial.
-
-The following arguments can be set:
-
-- ```window_size: int```: The length of the window. Must be an odd integer number. _Default: 5_.
-- ```polynomial_order: int```: The order of the polynomial used to fit the samples. Must be less than ```window_size```. _Default: 2_.
-- ```derivative_order: int```: The order of the derivative to compute. _Default: 1_.
-- ```mode: str```: The mode of the boundary. _Default: 'nearest'_, available options: ```'nearest'```, ```'constant'```, ```'reflect'```, ```'wrap'```, ```'mirror'```, ```'interp'```. See the [official documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.savgol_filter.html) for more information.
-
-Usage example:
-
-```python
-from chemotools.derivative import SavitzkyGolay
-
-sg = SavitzkyGolay(window_size=15, polynomial_order=2, derivate_order=1)
-spectra_derivative = sg.fit_transform(spectra)
-```
-
-![sgd](figures/sgd.png)
-
-### __William Norris derivative__
-William Norris derivative is a preprocessing technique in spectroscopy that calculates the derivative of a spectrum using finite differences.
-
-The following arguments can be set:
-
-- ```window_size: int```: The length of the window. Must be an odd integer number. _Default: 5_.
-- ```gap_size: int```: The number of points between the first and second points of the window. _Default: 3_.
-- ```derivative_order: int```: The order of the derivative to compute. _Default: 1_.
-- ```mode: str```: The mode of the boundary. _Default: 'nearest'_, available options: ```‘reflect’```, ```‘constant’```, ```‘nearest’```, ```‘mirror’```, ```‘wrap’```. See the [official documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.convolve.html) for more information.
-
-Usage example:
-
-```python
-from chemotools.derivative import NorrisWilliams
-
-nw = NorrisWilliams(window_size=15, gap_size=3, derivative_order=1)
-spectra_derivative =   nw.fit_transform(spectra)
-```
-![wn](figures/wn.png)
-
-## __Baseline__
-Baseline correction is a preprocessing technique in spectroscopy that corrects for baseline shifts and variations in signal intensity by subtracting a baseline from a spectrum. The following algorithms are available:
-
-- Linear baseline correction
-- Polynomial baseline correction
-- Cubic spline baseline correction
-- Alternate iterative reweighed penalized least squares (AIRPLS) baseline correction
-- Non-negative
-
-### __Linear baseline correction__
-Linear baseline correction is a preprocessing technique in spectroscopy that corrects for baseline shifts and variations in signal intensity by subtracting a linear baseline from a spectrum. The current implementation subtracts a linear baseline between the first and last point of the spectrum.
-
-Usage example:
-
-```python
-from chemotools.baseline import LinearCorrection
-
-lc = LinearCorrection()
-spectra_baseline = lc.fit_transform(spectra)
-```
-![lb](figures/lb.png)
-
-
-### __Polynomial baseline correction__
-Polynomial baseline correction is a preprocessing technique in spectroscopy that approximates a baseline by fitting a polynomial to selected points of the spectrum. The selected points often correspond to minima in the spectra, and are selected by their index (not by the wavenumber). If no points are selected, the algorithm will select the first and last point of the spectrum.
-
-The following arguments can be set:
-
-- ```order: int``` The order of the polynomial used to fit the samples. _Default: 1_.
-- ```indices: tuple``` The indices of the points to use for fitting the polynomial. _Default: (0, -1)_. At the moment the indices need to be specified manually as a tuple because ```scikit-learn``` does not support mutable attributes in ```BaseEstimator```. This tuple is transformed to a list when the ```transform``` method is called.
-
-Usage example:
-
-```python
-from chemotools.baseline import PolynomialCorrection
-
-pc = PolynomialCorrection(order=2, indices=(0, 75, 150, 200, 337))
-spectra_baseline = pc.fit_transform(spectra)
-```
-![pb](figures/pb.png)
-
-### __Cubic spline baseline correction__
-Cubic spline baseline correction is a preprocessing technique in spectroscopy that approximates a baseline by fitting a cubic spline to selected points of the spectrum. Similar to the ```PolynomialCorrection```, the selected points often correspond to minima in the spectra, and are selected by their index (not by the wavenumber). If no points are selected, the algorithm will select the first and last point of the spectrum. 
-
-The following arguments can be set:
-- ```indices: tuple``` The indices of the points to use for fitting the polynomial. _Default: None_. At the moment the indices need to be specified manually as a tuple because ```scikit-learn``` does not support mutable attributes in ```BaseEstimator```. This tuple is transformed to a list when the ```transform``` method is called.
-
-Usage example:
-
-```python
-from chemotools.baseline import CubicSplineCorrection
-
-cspl = CubicSplineCorrection(indices=(0, 75, 150, 200, 337))
-spectra_baseline = cspl.fit_transform(spectra)
-```
-
-![splines](figures/splines.png)
-
-### __Alternate iterative reweighed penalized least squares (AIRPLS) baseline correction__
-It is an automated baseline correction algorithm that uses a penalized least squares approach to fit a baseline to a spectrum. The original algorithm is based on the paper by [Zhang et al.](https://pubs.rsc.org/is/content/articlelanding/2010/an/b922045c). The current implementation is based on the Python implementation by [zmzhang](https://github.com/zmzhang/airPLS).
-
-The following arguments can be set:
-- ```nr_iterations: int``` The number of iterations before exiting the algorithm. _Default: 15_.
-- ```lam: float``` smoothing factor. _Default: 1e2_.
-- ```polynomial_order: int``` The order of the polynomial used to fit the samples. _Default: 1_.
-
-Usage example:
-
-```python
-from chemotools.baseline import AirPls
-
-airpls = AirPls()
-spectra_baseline = airpls.fit_transform(spectra)
-```
-
-![airpls](figures/airpls.png)
-
-### __Non-negative__
-Non-negative baseline correction is a preprocessing technique in spectroscopy that corrects for baseline by removing negative values from a spectrum. Negative values are either replaced by 0, or set to their absolute value.
-
-The following arguments can be set:
-- ```mode: str``` If ```'zero'```, negative values are replaced by 0. If ```'abs'```, negative values are set to their absolute value. _Default: ```'zero'```.
-
-Usage example:
-
-```python
-from chemotools.baseline import NonNegative
-
-nnz = NonNegative(mode='zero')
-nna = NonNegative(mode='abs')
-spectra_nnz = nnz.fit_transform(spectra_baseline)
-spectra_nna = nna.fit_transform(spectra_baseline)
-```
-
-![nnz](figures/nnz.png)
-![nna](figures/nna.png)
-
-## __Scale__
-Scale is a preprocessing technique in spectroscopy that scales the spectra. The following algorithms are available:
-- MinMaxScaler: scales each spectrum by its minimum or maximum value.
-- L-normalization: scales each spectrum by its L-norm.
-
-### __MinMax scaler__
-MinMaxScaler is a preprocessing technique in spectroscopy that scales each spectrum by its minimum or maximum value. 
-
-The following arguments can be set:
-- ```norm: str``` If ```'min'```, the spectrum is scaled by its minimum value. If ```'max'```, the spectrum is scaled by its maximum value. _Default: ```'max'```_.
-
-Usage example:
-
-```python
-from chemotools.scale import MinMaxScaler
-
-minmax = MinMaxScaler(norm='max')
-spectra_norm = minmax.fit_transform(spectra)
-```
-
-![minmax](figures/minmax.png)
-
-
-### __L-normalization__
-L-normalization is a preprocessing technique in spectroscopy that scales each spectrum by its L-norm. 
-
-The following arguments can be set:
-- ```l-norm: int``` The L-norm to use. _Default: ```2```_.
-
-Usage example:
-
-```python
-from chemotools.scale import LNormalize
-
-lnorm = LNormalize(l_norm=2)
-spectra_norm = lnorm.fit_transform(spectra)
-```
-
-![lnorm](figures/lnorm.png)
-
-## __Smooth__
-Smooth is a preprocessing technique in spectroscopy that smooths the spectra. The following algorithms are available:
-- Savitzky-Golay filter
-- Whittaker smoother
-- Mean filter
-- Median filter
-
-### __Savitzky-Golay filter__
-Savitzky-Golay filter is a preprocessing technique in spectroscopy that smooths the spectra by fitting a polynomial to the data. The current implementation is based on the ```scipy.signal.savgol_filter``` function.
-
-The following arguments can be set:
-
-- ```window_size: int```: The length of the window. Must be an odd integer number. _Default: 3_.
-- ```polynomial_order: int```: The order of the polynomial used to fit the samples. Must be less than ```window_size```. _Default: 1_.
-- ```derivative_order: int```: The order of the derivative to compute. _Default: 1_. ```'constant'```, ```'reflect'```, ```'wrap'```, ```'mirror'```, ```'interp'```. See the [official documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.savgol_filter.html) for more information.
-
-Usage example:
-
-```python
-from chemotools.smooth import SavitzkyGolayFilter
-
-sgf = SavitzkyGolayFilter(window_size=15, polynomial_order=2)
-spectra_norm = sgf.fit_transform(spectra)
-```
-
-![sgf](figures/sgf.png)
-
-### __Whittaker smoother__
-It is an automated smoothing algorithm that uses a penalized least squares approach to iteratively apply a smoothing operation to the data  by minimizing a penalty function that balances the degree of smoothness and the fidelity to the original data.
-
-The following arguments can be set:
-- ```lam: float``` smoothing factor. _Default: 1e2_.
-- ```differences: int``` The number of differences to use. _Default: 1_.
-
-Usage example:
-
-```python
-from chemotools.smooth import WhittakerSmooth
-
-wtk = WhittakerSmooth(lam=10)
-spectra_norm = wtk.fit_transform(spectra)
-```
-
-![wtk](figures/wtk.png)
-
-### __Mean filter__
-Mean filter is a preprocessing technique in spectroscopy that smooths the spectra by applying a mean filter. The current implementation is based on the ```scipy.ndimage.uniform_filter``` function.
-
-The following arguments can be set:
-- ```window_size: int```: The length of the window. Must be an odd integer number. _Default: 3_.
-- ```mode: str```: The mode parameter determines how the array borders are handled, where ```'constant'```, ```'reflect'```, ```'wrap'```, ```'mirror'```, ```'interp'```. See the [official documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.uniform_filter1d.html) for more information. _Default: ```'nearest'```_.
-
-Usage example:
-
-```python
-from chemotools.smooth import MeanFilter
-
-mean_filter = MeanFilter()
-spectra_norm = mean_filter.fit_transform(spectra)
-```
-
-![mean_filter](figures/mean_filter.png)
-
-### __Median filter__
-Median filter is a preprocessing technique in spectroscopy that smooths the spectra by applying a median filter. The current implementation is based on the ```scipy.ndimage.median_filter``` function.
-
-The following arguments can be set:
-- ```window_size: int```: The length of the window. Must be an odd integer number. _Default: 3_.
-- ```mode: str```: The mode parameter determines how the array borders are handled, where ```'constant'```, ```'reflect'```, ```'wrap'```, ```'mirror'```, ```'interp'```. See the [official documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.median_filter.html) for more information. _Default: ```'nearest'```_.
-
-Usage example:
-
-```python
-from chemotools.smooth import MedianFilter
-
-median_filter = MedianFilter()
-spectra_norm = median_filter.fit_transform(spectra)
-```
-
-![median_filter](figures/median_filter.png)