initial commit

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

README.md

@@ -1,13 +1,62 @@
+<img src="docs/images/aira-banner.png" alt="AIRA banner" style="display: block; margin: 0 auto; width:600px"/>
+
+[![License: GPL v2](https://img.shields.io/badge/License-GPL_v2-blue.svg)](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)
+
+---
+
+AIRA (Ambisonics Impulse Response Analyzer) is a novel software for visualizing impulse responses measured from Ambisonics microphones. Its innovative and interactive ui allows you to examine the reflections at a point with a hedgehog-type graph. It is also possible to export the graphs and print them on a floor plan of the analyzed room.
+
+Here are some previews:
+
+
+<img src="docs/images/aira-gui.png" alt="AIRA gui" style="display: block; margin: 0 auto; width:800px"/>
+
+
+  
 ---
-title: AIRA
-emoji: 👁
-colorFrom: blue
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
-license: gpl-2.0
+## 🆕 **Demo running**
+1. Download the repository
+    ```bash
+    git clone https://github.com/nahue-passano/AIRA.git
+    cd AIRA
+    ```
+
+2. Create and initialize [poetry](https://python-poetry.org/) environment
+    ```bash
+    poetry install
+    poetry shell
+    ```
+
+3. Run the GUI file
+    ```bash
+    python3 aira/gui.py
+    ```
+
+> **Usage note:** In case you do not have your own measurements, import test measurements from `test/mock_data/regio_theater`
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🌱 **Getting started (develop)**
+
+1. Download the repository
+    ```bash
+    git clone https://github.com/nahue-passano/AIRA.git
+    cd AIRA
+    ```
+
+2. Create and initialize [poetry](https://python-poetry.org/) environment
+    ```bash
+    poetry install
+    poetry shell
+    ```
+
+    > **Note**: If the environment already exists, run `poetry update` for possible changes in `pyproject.toml`.
+
+3. Install the pre-commit hooks for code formating and linting with `black` and `pylint`.
+    ```bash
+    pre-commit install
+    ```
+
+    > **Note**: If the changes to be commited are reformated, `black` will cancel the commit. You must add again the changes with `git add` and commit again
+
+---

aira/__init__.py

@@ -0,0 +1 @@
+"Ambisonics Impulse Response Analyzer module"

aira/core.py

@@ -0,0 +1,156 @@
+"""Core processing for AIRA module."""
+import numpy as np
+from dataclasses import dataclass
+from plotly import graph_objects as go
+
+from aira.engine.input import InputProcessorChain, InputMode
+from aira.engine.intensity import (
+    convert_bformat_to_intensity,
+    analysis_crop_2d,
+    integrate_intensity_directions,
+    intensity_thresholding,
+)
+from aira.engine.pressure import w_channel_preprocess
+from aira.engine.plot import hedgehog, w_channel, setup_plotly_layout, get_xy_projection
+from aira.engine.reflections import detect_reflections
+from aira.utils import read_signals_dict, cartesian_to_spherical
+
+
+INTEGRATION_TIME = 0.005
+INTENSITY_THRESHOLD = -60
+ANALYSIS_LENGTH = 1
+
+
+@dataclass
+class AmbisonicsImpulseResponseAnalyzer:
+    """Main class for analyzing Ambisonics impulse responses"""
+
+    integration_time: float = INTEGRATION_TIME
+    intensity_threshold: float = INTENSITY_THRESHOLD
+    analysis_length: float = ANALYSIS_LENGTH
+    bformat_frequency_correction: bool = True
+    input_builder = InputProcessorChain()
+
+    def analyze(
+        self,
+        input_dict: dict,
+        integration_time: float = INTEGRATION_TIME,
+        intensity_threshold: float = INTENSITY_THRESHOLD,
+        analysis_length: float = ANALYSIS_LENGTH,
+        show: bool = False,
+    ) -> go.Figure:
+        """Analyzes a set of measurements in Ambisonics format and plots a hedgehog
+        with the estimated reflections direction.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Dictionary with all the data needed to analyze a set of measurements
+            (paths of the measurements, input mode, channels per file, etc.)
+        integration_time : float, optional
+            Time frame where intensity vectors are integrated by the mean of them,
+            by default INTEGRATION_TIME
+        intensity_threshold : float, optional
+            Bottom limit for intensity values in dB, by default INTENSITY_THRESHOLD
+        analysis_length : float, optional
+            Total time of analysis from intensity max peak, by default ANALYSIS_LENGTH
+        show : bool, optional
+            Shows plotly figure in browser, by default False
+
+        Returns
+        -------
+        go.Figure
+            Plotly figure with hedgehog and w-channel plot
+        """
+
+        signals_dict = read_signals_dict(input_dict)
+        sample_rate = signals_dict["sample_rate"]
+
+        bformat_signals = self.input_builder.process(input_dict)
+
+        intensity_directions = convert_bformat_to_intensity(bformat_signals)
+
+        intensity_directions_cropped = analysis_crop_2d(
+            analysis_length, sample_rate, intensity_directions
+        )
+
+        intensity_windowed, time = integrate_intensity_directions(
+            intensity_directions_cropped, integration_time, sample_rate
+        )
+
+        intensity, azimuth, elevation = cartesian_to_spherical(intensity_windowed)
+
+        (
+            intensity_peaks,
+            azimuth_peaks,
+            elevation_peaks,
+            reflections_idx,
+        ) = detect_reflections(intensity, azimuth, elevation)
+
+        (
+            reflex_to_direct,
+            azimuth_peaks,
+            elevation_peaks,
+            reflections_idx,
+        ) = intensity_thresholding(
+            intensity_threshold,
+            intensity_peaks,
+            azimuth_peaks,
+            elevation_peaks,
+            reflections_idx,
+        )
+
+        time = time[reflections_idx]
+
+        fig = setup_plotly_layout()
+
+        hedgehog(fig, time, reflex_to_direct, azimuth_peaks, elevation_peaks)
+
+        w_channel_signal = w_channel_preprocess(
+            bformat_signals[0, :],
+            int(integration_time * sample_rate),
+            analysis_length,
+            sample_rate,
+        )
+
+        w_channel(
+            fig,
+            np.arange(0, analysis_length, 1 / sample_rate) * 1000,
+            w_channel_signal,
+            intensity_threshold,
+            time,
+        )
+
+        if show:
+            fig.show()
+        return fig
+
+    def export_xy_projection(self, fig: go.Figure, img_name: str):
+        new_fig = get_xy_projection(fig)
+        new_fig.write_image(img_name, format="png")
+
+
+if __name__ == "__main__":
+    # Regio theater
+    data = {
+        "front_left_up": "test/mock_data/regio_theater/soundfield_flu.wav",
+        "front_right_down": "test/mock_data/regio_theater/soundfield_frd.wav",
+        "back_right_up": "test/mock_data/regio_theater/soundfield_bru.wav",
+        "back_left_down": "test/mock_data/regio_theater/soundfield_bld.wav",
+        "inverse_filter": "test/mock_data/regio_theater/soundfield_inverse_filter.wav",
+        "input_mode": InputMode.LSS,
+        "channels_per_file": 1,
+        "frequency_correction": True,
+    }
+
+    # York auditorium
+    # data = {
+    #     "stacked_signals": "test/mock_data/york_auditorium/s2r2.wav",
+    #     "input_mode": InputMode.BFORMAT,
+    #     "channels_per_file": 4,
+    #     "frequency_correction": False,
+    # }
+
+    analyzer = AmbisonicsImpulseResponseAnalyzer()
+    fig = analyzer.analyze(data, show=True)
+    analyzer.export_xy_projection(fig, "projection.png")

aira/engine/filtering.py

@@ -0,0 +1,152 @@
+"""Functionality for filtering signals."""
+
+import numpy as np
+from scipy.signal import bilinear, firwin, kaiserord, lfilter
+
+MIC2CENTER = 3
+SOUND_SPEED = 340
+FILTER_TRANSITION_WIDTH_HZ = 250.0
+FILTER_RIPPLE_DB = 60.0
+
+
+class NonCoincidentMicsCorrection:
+    """Class for correct frequency response in Ambisonics B-format representation."""
+
+    def __init__(
+        self,
+        sample_rate: int,
+        mic2center: float = MIC2CENTER,
+        sound_speed: float = SOUND_SPEED,
+    ) -> None:
+        self.sample_rate = sample_rate
+        self.mic2center = mic2center / 100
+        self.sound_speed = sound_speed
+        self.delay2center = self.mic2center / self.sound_speed
+
+    def _filter(
+        # pylint: disable=invalid-name
+        self,
+        b: np.ndarray,
+        a: np.ndarray,
+        array: np.ndarray,
+    ) -> np.ndarray:
+        """Applies filter to array given numerator "b" and denominator "a" from
+        analog filter frequency response
+
+        Parameters
+        ----------
+        b : np.ndarray
+            Array containing numerator's coefficients
+        a : np.ndarray
+            Array containing denominator's coefficients
+        array : np.ndarray
+            Array to be filtered
+
+        Returns
+        -------
+        np.ndarray
+            Filtered array
+        """
+
+        # Analog to digital filter conversion
+        zeros, poles = bilinear(b, a, self.sample_rate)
+
+        # Filtering
+        array_filtered = lfilter(zeros, poles, array)
+
+        return array_filtered
+
+    def correct_axis(self, axis_signal: np.ndarray) -> np.ndarray:
+        """Applies correction filter to axis array signal
+
+        Parameters
+        ----------
+        axis_signal : np.ndarray
+            Array containing axis signal
+
+        Returns
+        -------
+        np.ndarray
+            Axis array signal corrected
+        """
+        # Filter equations
+        # pylint: disable=invalid-name
+        b = np.sqrt(6) * np.array(
+            [1, 1j * (1 / 3) * self.mic2center, -(1 / 3) * self.delay2center**2]
+        )
+        # pylint: disable=invalid-name
+        a = np.array([1, 1j * (1 / 3) * self.delay2center])
+
+        axis_corrected = self._filter(b, a, axis_signal)
+
+        return axis_corrected
+
+    def correct_omni(self, omni_signal: np.ndarray) -> np.ndarray:
+        """Applies correction filter to omnidirectional array signal
+
+        Parameters
+        ----------
+        omni_signal : np.ndarray
+            Array containing omnidirectional signal
+
+        Returns
+        -------
+        np.ndarray
+            Omnidirectional array signal corrected
+        """
+        # Filter equations
+        # pylint: disable=invalid-name
+        b = np.array([1, 1j * self.delay2center, -(1 / 3) * self.delay2center**2])
+        # pylint: disable=invalid-name
+        a = np.array([1, 1j * (1 / 3) * self.delay2center])
+
+        omni_corrected = self._filter(b, a, omni_signal)
+
+        return omni_corrected
+
+
+def apply_low_pass_filter(
+    signal: np.ndarray, cutoff_frequency: int, sample_rate: int
+) -> np.ndarray:
+    """Filter a signal at the given cutoff with an optimized number of taps
+    (order of the filter).
+
+    Args:
+        signal (np.ndarray): signal to filter.
+        cutoff_frequency (int): cutoff frequency.
+        sample_rate (int): sample rate of the signal.
+
+    Returns:
+        np.ndarray: filtered signal.
+    """
+    nyquist_rate = sample_rate / 2.0
+
+    # Compute FIR filter parameters and apply to signal.
+    transition_width_normalized = FILTER_TRANSITION_WIDTH_HZ / nyquist_rate
+    filter_length, filter_beta = kaiserord(
+        FILTER_RIPPLE_DB, transition_width_normalized
+    )
+    filter_coefficients = firwin(
+        filter_length, cutoff_frequency / nyquist_rate, window=("kaiser", filter_beta)
+    )
+
+    return lfilter(filter_coefficients, 1.0, signal)
+
+
+def moving_average_filter(array: np.ndarray, window_size: int) -> np.ndarray:
+    """_summary_
+
+    Parameters
+    ----------
+    array : np.ndarray
+        _description_
+    window_size : int
+        _description_
+
+    Returns
+    -------
+    np.ndarray
+        _description_
+    """
+    window = np.ones(window_size) / window_size
+    return np.convolve(array, window, mode="valid")

aira/engine/input.py

@@ -0,0 +1,149 @@
+"""Input preprocessing module."""
+from abc import ABC, abstractmethod
+from enum import Enum
+
+import numpy as np
+from scipy.signal import fftconvolve
+
+from aira.engine.filtering import NonCoincidentMicsCorrection
+from aira.utils import convert_ambisonics_a_to_b
+
+
+# pylint: disable=too-few-public-methods
+class InputMode(Enum):
+    """Enum class for accessing the existing `InputMode`s"""
+
+    LSS = "lss"
+    AFORMAT = "aformat"
+    BFORMAT = "bformat"
+
+
+# pylint: disable=too-few-public-methods
+class InputProcessor(ABC):
+    """Base interface for inputs processors"""
+
+    @abstractmethod
+    def process(self, input_dict: dict) -> dict:
+        """Abstract method to be overwritten by concrete implementations of
+        input processing."""
+
+
+# pylint: disable=too-few-public-methods
+class LSSInputProcessor(InputProcessor):
+    """Processing when input data is in LSS mode"""
+
+    def process(self, input_dict: dict) -> dict:
+        """Gets impulse response arrays from Long Sine Sweep (LSS) measurements. The new
+        signals are in A-Format.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Dictionary with LSS measurement arrays
+
+        Returns
+        -------
+        dict
+            input_dict overwritten with A-Format signals
+        """
+        if input_dict["input_mode"] != InputMode.LSS:
+            return input_dict
+
+        input_dict["stacked_signals"] = np.apply_along_axis(
+            lambda array: fftconvolve(array, input_dict["inverse_filter"], mode="full"),
+            axis=1,
+            arr=input_dict["stacked_signals"],
+        )
+        input_dict["input_mode"] = InputMode.AFORMAT
+
+        return input_dict
+
+
+# pylint: disable=too-few-public-methods
+class AFormatProcessor(InputProcessor):
+    """Processing when input data is in mode AFORMAT"""
+
+    def process(self, input_dict: dict) -> dict:
+        """Gets B-format arrays from A-format arrays. For more details see
+        aira.utils.formatter.convert_ambisonics_a_to_b function.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Dictionary with A-format arrays
+
+        Returns
+        -------
+        dict
+            input_dict overwritten with B-format signals
+        """
+        if input_dict["input_mode"] != InputMode.AFORMAT:
+            return input_dict
+        input_dict["stacked_signals"] = convert_ambisonics_a_to_b(
+            input_dict["stacked_signals"][0, :],
+            input_dict["stacked_signals"][1, :],
+            input_dict["stacked_signals"][2, :],
+            input_dict["stacked_signals"][3, :],
+        )
+        input_dict["input_mode"] = InputMode.BFORMAT
+        return input_dict
+
+
+# pylint: disable=too-few-public-methods
+class BFormatProcessor(InputProcessor):
+    """Processin when input data is in BFORMAT mode."""
+
+    def process(self, input_dict: dict) -> dict:
+        """Corrects B-format arrays frequency response for non-coincident microphones.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Dictionary with B-format arrays.
+
+        Returns
+        -------
+        dict
+            input_dict overwritten with B-format frequency corrected arrays.
+        """
+        if input_dict["input_mode"] != InputMode.BFORMAT and not bool(
+            input_dict["frequency_correction"]
+        ):
+            return input_dict
+
+        frequency_corrector = NonCoincidentMicsCorrection(input_dict["sample_rate"])
+
+        input_dict["stacked_signals"][0, :] = frequency_corrector.correct_omni(
+            input_dict["stacked_signals"][0, :]
+        )
+        input_dict["stacked_signals"][1:, :] = frequency_corrector.correct_axis(
+            input_dict["stacked_signals"][1:, :]
+        )
+        input_dict["input_mode"] = InputMode.BFORMAT
+        return input_dict
+
+
+# pylint: disable=too-few-public-methods
+class InputProcessorChain:
+    """Chain of input processors"""
+
+    def __init__(self):
+        self.processors = [LSSInputProcessor(), AFormatProcessor(), BFormatProcessor()]
+
+    def process(self, input_dict: dict) -> np.ndarray:
+        """Applies the chain of processors for the input_mode setted.
+
+        Parameters
+        ----------
+        input_dict : dict
+            Contains arrays and input mode data
+
+        Returns
+        -------
+        np.ndarray
+            Arrays processed stacked in single numpy.ndarray object
+        """
+        for process_i in self.processors:
+            input_dict = process_i.process(input_dict)
+
+        return input_dict["stacked_signals"]

aira/engine/intensity.py

@@ -0,0 +1,173 @@
+"""Functionality for intensity computation and related signal processing."""
+
+from typing import Tuple
+
+import numpy as np
+
+from aira.engine.filtering import apply_low_pass_filter
+
+FILTER_CUTOFF = 5000
+OVERLAP_RATIO = 0.5
+
+
+def analysis_crop_2d(
+    analysis_length: float,
+    sample_rate: int,
+    intensity_directions: np.ndarray,
+):
+    """_summary_
+
+    Parameters
+    ----------
+    analysis_length : float
+        _description_
+    sample_rate : int
+        _description_
+    intensity_directions : np.ndarray
+        _description_
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    # Get analysis length max index
+    analysis_length_idx = int(analysis_length * sample_rate)
+
+    # Slice from intensity max to analysis length from intensity max
+    earliest_peak_index = np.argmax(np.abs(intensity_directions), axis=1).min()
+    intensity_directions_cropped = intensity_directions[
+        :, earliest_peak_index : earliest_peak_index + analysis_length_idx
+    ]
+
+    return intensity_directions_cropped
+
+
+def intensity_thresholding(
+    threshold: float,
+    intensity: np.ndarray,
+    azimuth: np.ndarray,
+    elevation: np.ndarray,
+    reflections: np.ndarray,
+) -> Tuple[np.ndarray]:
+    """_summary_
+
+    Parameters
+    ----------
+    threshold : _type_
+        _description_
+    """
+    reflex_to_direct = intensity_to_dB(intensity) - intensity_to_dB(intensity[0])
+    thresholding_mask = reflex_to_direct > threshold
+    return (
+        reflex_to_direct[thresholding_mask],
+        azimuth[thresholding_mask],
+        elevation[thresholding_mask],
+        reflections[thresholding_mask],
+    )
+
+
+def intensity_to_dB(intensity_array: np.ndarray) -> np.ndarray:
+    """Converts intensity to dB scale using 1e-12 as intensity reference
+
+    Parameters
+    ----------
+    intensity_array : np.ndarray
+        Intensity array
+
+    Returns
+    -------
+    np.ndarray
+        Intensity array in dB scale
+    """
+    return 10 * np.log10(intensity_array / 1e-12)
+
+
+def min_max_normalization(array: np.ndarray) -> np.ndarray:
+    """Returns the input array normalized by its minimum and maximum value.
+
+    Parameters
+    ----------
+    array : np.ndarray
+        Array to be normalized
+
+    Returns
+    -------
+    np.ndarray
+        Array normalized
+    """
+    return (array - array.min() * 1.1) / (array.max() - array.min() * 1.1)
+
+
+def integrate_intensity_directions(
+    intensity_directions: np.ndarray,
+    duration_secs: float,
+    sample_rate: int,
+) -> np.ndarray:
+    """Integrate the intensity signal with Hamming windows of length `duration_secs`.
+
+    Args:
+        intensity_directions (np.ndarray): X, Y and Z intensity signals.
+        duration_secs (float): the length of the window to apply, in seconds.
+        sample_rate (int): sampling rate of the signal.
+
+    Returns:
+        np.ndarray: the integrated signal, of shape (3, ...)
+    """
+    if intensity_directions.shape[0] == 4:
+        intensity_directions = intensity_directions[1:, :]
+    elif (intensity_directions.shape[0] < 3) or (intensity_directions.shape[0] > 4):
+        raise ValueError(f"Unexpected input shape {intensity_directions.shape}")
+
+    # Convert integration time to samples
+    duration_samples = np.round(duration_secs * sample_rate).astype(np.int64)
+
+    # Padding and windowing
+    hop_size = int(duration_samples * (1 - OVERLAP_RATIO))
+    intensity_directions = np.concatenate(
+        [
+            intensity_directions,
+            np.zeros((3, intensity_directions.shape[1] % hop_size)),
+        ],
+        axis=1,
+    )
+    output_shape = (
+        3,
+        int(intensity_directions.shape[1] / duration_samples / OVERLAP_RATIO) - 1,
+    )
+    intensity_windowed = np.zeros(output_shape)
+    time = np.zeros(output_shape[1])
+    window = np.hamming(duration_samples)
+
+    for i in range(0, output_shape[1]):
+        intensity_segment = intensity_directions[
+            :, i * hop_size : i * hop_size + duration_samples
+        ]
+        intensity_windowed[:, i] = np.mean(intensity_segment * window, axis=1)
+        time[i] = i * hop_size / sample_rate
+
+    # Add direct sound first with no windowing
+    intensity_windowed = np.insert(
+        intensity_windowed, 0, intensity_directions[:, 0], axis=1
+    )
+
+    return intensity_windowed, time
+
+
+def convert_bformat_to_intensity(signal: np.ndarray) -> Tuple[np.ndarray]:
+    """Integrate and compute intensities for a B-format Ambisonics recording.
+
+    Args:
+        signal (np.ndarray): input B-format Ambisonics signal. Shape: (4, N).
+
+    Returns:
+        Tuple[np.ndarray]: integrated intensity, azimuth and elevation.
+    """
+    # signal_filtered = apply_low_pass_filter(signal, cutoff_frequency, sample_rate)
+    signal_filtered = signal
+
+    # Calculate intensity from directions
+    intensity_directions = (
+        signal_filtered[0, :] * signal_filtered[1:, :]
+    )  # Intensity = pressure (W channel) * pressure gradient (XYZ channels)
+    return intensity_directions

aira/engine/plot.py

@@ -0,0 +1,266 @@
+"""Plotting functions."""
+from typing import Tuple, Dict
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+from aira.utils.formatter import spherical_to_cartesian
+from aira.engine.intensity import min_max_normalization
+
+
+def hedgehog(
+    fig: go.Figure,
+    time_peaks: np.ndarray,
+    reflex_to_direct: np.ndarray,
+    azimuth_peaks: np.ndarray,
+    elevation_peaks: np.ndarray,
+) -> go.Figure:
+    """Create a hedgehog plot."""
+    time_peaks *= 1000  # seconds to miliseconds
+    normalized_intensities = min_max_normalization(reflex_to_direct)
+    # pylint: disable=invalid-name
+    x, y, z = spherical_to_cartesian(
+        normalized_intensities, azimuth_peaks, elevation_peaks
+    )
+
+    fig.add_trace(
+        go.Scatter3d(
+            x=zero_inserter(x),
+            y=zero_inserter(y),
+            z=zero_inserter(z),
+            marker={
+                "color": zero_inserter(normalized_intensities),
+                "colorscale": "portland",
+                "colorbar": {
+                    "thickness": 20,
+                    "tickvals": [0.99],
+                    "ticktext": ["Direct          <br>sound          "],
+                    "ticklabelposition": "inside",
+                    "ticksuffix": "                     ",
+                    "ticklabeloverflow": "allow",
+                    "title": {"text": "<b>Time</b>"},
+                },
+                "size": 3,
+            },
+            line={
+                "width": 8,
+                "color": zero_inserter(normalized_intensities),
+                "colorscale": "portland",
+            },
+            customdata=np.stack(
+                (
+                    zero_inserter(reflex_to_direct),
+                    zero_inserter(time_peaks),
+                    zero_inserter(azimuth_peaks),
+                    zero_inserter(elevation_peaks),
+                ),
+                axis=-1,
+            ),
+            hovertemplate="<b>Reflection-to-direct [dB]:</b> %{customdata[0]:.2f} dB <br>"
+            + "<b>Time [ms]: </b>%{customdata[1]:.2f} ms <br>"
+            + "<b>Azimuth [°]: </b>%{customdata[2]:.2f}° <br>"
+            + "<b>Elevation [°]: </b>%{customdata[3]:.2f}° <extra></extra>",
+            showlegend=False,
+        ),
+        row=1,
+        col=1,
+    )
+
+    fig.update_layout(
+        scene={
+            "aspectmode": "cube",
+            "xaxis": {
+                "zerolinecolor": "white",
+                "showbackground": False,
+                "showticklabels": False,
+            },
+            "xaxis_title": " ◀️ Front - Rear ▶",
+            "yaxis": {
+                "zerolinecolor": "white",
+                "showbackground": False,
+                "showticklabels": False,
+            },
+            "yaxis_title": " ◀️ Right - Left ▶",
+            "zaxis": {
+                "zerolinecolor": "white",
+                "showbackground": False,
+                "showticklabels": False,
+            },
+            "zaxis_title": " ◀️ Up - Down ▶",
+        },
+    )
+    return fig
+
+
+def w_channel(
+    fig: go.Figure,
+    time: np.ndarray,
+    w_channel: np.ndarray,
+    ylim: float,
+    time_reflections: np.ndarray,
+) -> go.Figure:
+    """_summary_
+
+    Parameters
+    ----------
+    fig : go.Figure
+        _description_
+    """
+    fig.add_trace(
+        go.Scatter(
+            x=time,
+            y=w_channel,
+            customdata=time,
+            hovertemplate="<b>Time [ms]:</b> %{customdata:.2f} ms <extra></extra>",
+            showlegend=False,
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            mode="markers",
+            marker={"symbol": "star-diamond", "size": 10, "color": "rgb(72,116,212)"},
+            x=time_reflections,
+            y=np.ones_like(time_reflections) * 0.95,
+            customdata=time_reflections,
+            hovertemplate="<b>Time [ms]:</b> %{customdata:.2f} ms <extra></extra>",
+            showlegend=False,
+        )
+    )
+    fig.update_layout(yaxis_range=[0, 1], xaxis_range=[0, max(time)])
+    fig.update_xaxes(title_text="Time [ms]", row=2, col=1)
+    fig.update_yaxes(title_text="Relative amplitude", row=2, col=1)
+
+
+def setup_plotly_layout() -> go.Figure:
+    """_summary_
+
+    Parameters
+    ----------
+    fig : go.Figure
+        _description_
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    fig = make_subplots(
+        rows=2,
+        cols=1,
+        row_heights=[0.85, 0.15],
+        vertical_spacing=0.05,
+        specs=[[{"type": "scene"}], [{"type": "xy"}]],
+        subplot_titles=("<b>Hedgehog</b>", "<b>Omnidirectional channel</b>"),
+    )
+
+    camera, buttons = get_plotly_scenes()
+
+    fig.update_layout(
+        template="plotly_dark",
+        margin={"l": 0, "r": 100, "t": 30, "b": 0},
+        paper_bgcolor="rgb(49,52,56)",
+        plot_bgcolor="rgb(49,52,56)",
+        scene_camera=camera,
+        updatemenus=[{"buttons": buttons}],
+        showlegend=False,
+    )
+    return fig
+
+
+def get_plotly_scenes() -> Tuple[Dict]:
+    """_summary_
+
+    Returns
+    -------
+    Tuple[Dict]
+        _description_
+    """
+    camera = {
+        "up": {"x": 0, "y": 0, "z": 1},
+        "center": {"x": 0, "y": 0, "z": 0},
+        "eye": {"x": 1.3, "y": 1.3, "z": 0.2},
+    }
+
+    button0 = {
+        "method": "relayout",
+        "args": [{"scene.camera.eye": {"x": 1.3, "y": 1.3, "z": 0.2}}],
+        "label": "3D perspective",
+    }
+
+    button1 = {
+        "method": "relayout",
+        "args": [
+            {
+                "scene.camera.eye": {"x": 0.0, "y": 0.0, "z": 2},
+                "scene.camera.up": {"x": 0.0, "y": 0.0, "z": 2},
+            }
+        ],
+        "label": "X-Y plane",
+    }
+
+    button2 = {
+        "method": "relayout",
+        "args": [{"scene.camera.eye": {"x": 0.0, "y": 2, "z": 0.0}}],
+        "label": "X-Z plane",
+    }
+
+    button3 = {
+        "method": "relayout",
+        "args": [{"scene.camera.eye": {"x": 2, "y": 0.0, "z": 0.0}}],
+        "label": "Y-Z plane",
+    }
+    buttons = [button0, button1, button2, button3]
+    return camera, buttons
+
+
+def get_xy_projection(fig: go.Figure) -> go.Figure:
+    # Removing omnidireccional channel plot
+    traces = list(fig.data)
+    traces.pop(1)
+
+    # Creating new figure for xy projection
+    new_fig = make_subplots()
+    new_fig.add_trace(traces[0])
+
+    # Removing axes in Scatter plot
+    new_fig.update_layout(
+        scene={
+            "xaxis": {"visible": False},
+            "yaxis": {"visible": False},
+            "zaxis": {"visible": False},
+        }
+    )
+
+    # Removing colorbar
+    new_fig.update_traces(marker_showscale=False)
+
+    # Setting cenital camera and cube mode
+    new_fig.update_layout(
+        scene={"aspectmode": "cube"},
+        scene_camera={
+            "up": {"x": 0, "y": 1, "z": 0},
+            "center": {"x": 0, "y": 0, "z": 0},
+            "eye": {"x": 0, "y": 0, "z": 1.5},
+        },
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+    )
+
+    return new_fig
+
+
+def zero_inserter(array: np.ndarray) -> np.ndarray:
+    """_summary_
+
+    Parameters
+    ----------
+    array : np.ndarray
+        _description_
+
+    Returns
+    -------
+    np.ndarray
+        _description_
+    """
+    return np.insert(array, np.arange(len(array)), values=0)

aira/engine/pressure.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from aira.engine.filtering import moving_average_filter
+
+
+def w_channel_preprocess(
+    w_channel: np.ndarray, window_size: int, analysis_length: float, sample_rate: float
+) -> np.ndarray:
+    """_summary_
+
+    Parameters
+    ----------
+    w_channel : np.ndarray
+        _description_
+    window_size : int
+        _description_
+    analysis_length : float
+        _description_
+    sample_rate : float
+        _description_
+
+    Returns
+    -------
+    np.ndarray
+        _description_
+    """
+    w_channel_cropped = np.abs(
+        analysis_crop_1d(w_channel, analysis_length, sample_rate)
+    )
+    w_channel_filtered = moving_average_filter(w_channel_cropped, int(window_size / 2))
+    w_channel_filtered /= np.max(w_channel_filtered)
+    return w_channel_filtered
+
+
+def analysis_crop_1d(
+    array: np.ndarray,
+    analysis_length: float,
+    sample_rate: int,
+):
+    """_summary_
+
+    Parameters
+    ----------
+    analysis_length : float
+        _description_
+    sample_rate : int
+        _description_
+    array : np.ndarray
+        _description_
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    # Get analysis length max index
+    analysis_length_idx = int(analysis_length * sample_rate)
+
+    # Slice from intensity max to analysis length from intensity max
+    earliest_peak_index = np.argmax(np.abs(array))
+    array_cropped = array[
+        earliest_peak_index : earliest_peak_index + analysis_length_idx
+    ]
+
+    return array_cropped

aira/engine/reflections.py

@@ -0,0 +1,117 @@
+"""Functionality for detecting reflections in a room impulse response (RIR)."""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Tuple, Union
+
+import numpy as np
+from scipy.signal import find_peaks, find_peaks_cwt
+
+
+# pylint: disable=too-few-public-methods
+class ReflectionDetectionStrategy(ABC):
+    """Base interface for a reflection detection algorithm."""
+
+    @staticmethod
+    @abstractmethod
+    def get_indeces_of_reflections(intensity_magnitude: np.ndarray) -> np.ndarray:
+        """Abstract method to be overwritten by concrete implementations of
+        reflection detection."""
+
+
+# pylint: disable=too-few-public-methods
+class CorrelationReflectionDetectionStrategy(ReflectionDetectionStrategy):
+    """Algorithm for detecting reflections based on the correlation."""
+
+    @staticmethod
+    def get_indeces_of_reflections(intensity_magnitude: np.ndarray) -> np.ndarray:
+        raise NotImplementedError("Implemented method is Scipy's find_peaks")
+
+
+# pylint: disable=too-few-public-methods
+class ThresholdReflectionDetectionStrategy(ReflectionDetectionStrategy):
+    """Algorithm for detecting reflections based on a threshold."""
+
+    @staticmethod
+    def get_indeces_of_reflections(intensity_magnitude: np.ndarray) -> np.ndarray:
+        raise NotImplementedError("Implemented method is Scipy's find_peaks")
+
+
+# pylint: disable=too-few-public-methods
+class NeighborReflectionDetectionStrategy(ReflectionDetectionStrategy):
+    """Algorithm for detecting reflections based on the surrounding values
+    of local maxima."""
+
+    @staticmethod
+    def get_indeces_of_reflections(intensity_magnitude: np.ndarray) -> np.ndarray:
+        """Find local maxima in the intensity magnitude signal.
+
+        Args:
+            intensity_magnitude (np.ndarray): intensity magnitude signal.
+
+        Returns:
+            np.ndarray: an array with the indeces of the peaks.
+        """
+        # Drop peak properties ([0]) and direct sound peak ([1])
+        return find_peaks(intensity_magnitude)[0]
+
+
+class WaveletReflectionDetectionStrategy(ReflectionDetectionStrategy):
+    """Algorithm for detecting reflections based on the wavelet transform"""
+
+    @staticmethod
+    def get_indeces_of_reflections(intensity_magnitude: np.ndarray) -> np.ndarray:
+        """Find local maxima in the intensity magnitude signal.
+
+        Args:
+            intensity_magnitude (np.ndarray): intensity magnitude signal.
+
+        Returns:
+            np.ndarray: an array with the indeces of the peaks.
+        """
+        # Drop peak properties ([0]) and direct sound peak ([1])
+        return find_peaks_cwt(intensity_magnitude, widths=np.arange(5, 15))[0]
+
+
+class ReflectionDetectionStrategies(Enum):
+    """Enum class for accessing the existing `ReflectionDetectionStrategy`s"""
+
+    CORRELATION = CorrelationReflectionDetectionStrategy
+    THRESHOLD = ThresholdReflectionDetectionStrategy
+    SCIPY = NeighborReflectionDetectionStrategy
+    WAVELET = WaveletReflectionDetectionStrategy
+
+
+def detect_reflections(
+    intensity: np.ndarray,
+    azimuth: np.ndarray,
+    elevation: np.ndarray,
+    detection_strategy: Union[
+        ReflectionDetectionStrategy, ReflectionDetectionStrategies
+    ] = NeighborReflectionDetectionStrategy,
+) -> Tuple[np.ndarray]:
+    """Analyze the normalized intensity, azimuth and elevation arrays to look for
+    reflections. Timeframes which don't contain a reflection are masked.
+
+    Args:
+        intensity (np.ndarray): normalized intensity array.
+        azimuth (np.ndarray): array with horizontal angles with respect to the XZ plane.
+        elevation (np.ndarray): array with vertical angles with respect to the XY plane.
+
+    Returns:
+        intensity (np.ndarray): masked intensities with only reflections different than 0.
+        azimuth (np.ndarray): masked intensities with only reflections different than 0.
+        elevation (np.ndarray): masked intensities with only reflections different than 0.
+    """
+    if isinstance(detection_strategy, ReflectionDetectionStrategies):
+        detection_strategy = detection_strategy.value
+
+    reflections_indeces = detection_strategy.get_indeces_of_reflections(intensity)
+    # Add direct sound
+    reflections_indeces = np.insert(reflections_indeces, 0, 0)
+    return (
+        intensity[reflections_indeces],
+        azimuth[reflections_indeces],
+        elevation[reflections_indeces],
+        reflections_indeces,
+    )

aira/gui.py

@@ -0,0 +1,1104 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'GUI_v1.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.9
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets, QtWebEngineWidgets
+from PyQt5.QtWidgets import (
+    QLabel,
+    QFileDialog,
+    QMessageBox,
+)
+from PyQt5.QtGui import QPixmap
+from PyQt5.QtCore import Qt
+import os
+from pathlib import Path
+
+from aira.core import AmbisonicsImpulseResponseAnalyzer
+from aira.engine.input import InputMode
+
+INTEGRATION_TIME = 0.01
+
+analyzer = AmbisonicsImpulseResponseAnalyzer(integration_time=INTEGRATION_TIME)
+
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName("MainWindow")
+        MainWindow.resize(1350, 727)
+        MainWindow.setMinimumSize(QtCore.QSize(1000, 800))
+        MainWindow.setWindowIcon(QtGui.QIcon(str(Path("docs/images/aira-icon.png"))))
+        self.centralwidget = QtWidgets.QWidget(MainWindow)
+        self.centralwidget.setStyleSheet("background-color:#313438 ; ")
+        self.centralwidget.setObjectName("centralwidget")
+        self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
+        self.verticalLayout.setContentsMargins(0, 0, 0, 0)
+        self.verticalLayout.setSpacing(0)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.frame_main = QtWidgets.QFrame(self.centralwidget)
+        self.frame_main.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_main.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_main.setObjectName("frame_main")
+        self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.frame_main)
+        self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
+        self.verticalLayout_2.setSpacing(0)
+        self.verticalLayout_2.setObjectName("verticalLayout_2")
+        self.tabWidget = QtWidgets.QTabWidget(self.frame_main)
+        self.tabWidget.setObjectName("tabWidget")
+        self.tab_main = QtWidgets.QWidget()
+        self.tab_main.setObjectName("tab_main")
+        self.horizontalLayout = QtWidgets.QHBoxLayout(self.tab_main)
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        self.frame_inputs = QtWidgets.QFrame(self.tab_main)
+        self.frame_inputs.setMaximumSize(QtCore.QSize(300, 16777215))
+        self.frame_inputs.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_inputs.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_inputs.setObjectName("frame_inputs")
+        self.verticalLayout_7 = QtWidgets.QVBoxLayout(self.frame_inputs)
+        self.verticalLayout_7.setObjectName("verticalLayout_7")
+        spacerItem = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem)
+        spacerItem1 = QtWidgets.QSpacerItem(
+            277, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem1)
+        self.frame_logo_main = QtWidgets.QFrame(self.frame_inputs)
+        self.frame_logo_main.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_logo_main.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_logo_main.setObjectName("frame_logo_main")
+        self.label_logo_main = QtWidgets.QLabel(self.frame_logo_main)
+        self.label_logo_main.setGeometry(QtCore.QRect(20, 30, 177, 50))
+        self.label_logo_main.setMaximumSize(QtCore.QSize(500, 500))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(69, 113, 213))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(69, 113, 213))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.label_logo_main.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Medel")
+        font.setPointSize(24)
+        self.label_logo_main.setFont(font)
+        self.label_logo_main.setText("")
+        self.label_logo_main.setPixmap(
+            QtGui.QPixmap(str(Path("docs/images/aira-logo.png")))
+        )
+        self.label_logo_main.setScaledContents(True)
+        self.label_logo_main.setAlignment(QtCore.Qt.AlignCenter)
+        self.label_logo_main.setObjectName("label_logo_main")
+        self.verticalLayout_7.addWidget(self.frame_logo_main)
+        self.frame_settings = QtWidgets.QFrame(self.frame_inputs)
+        self.frame_settings.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_settings.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_settings.setObjectName("frame_settings")
+        self.verticalLayout_5 = QtWidgets.QVBoxLayout(self.frame_settings)
+        self.verticalLayout_5.setObjectName("verticalLayout_5")
+        self.frame_analyze = QtWidgets.QFrame(self.frame_settings)
+        self.frame_analyze.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_analyze.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_analyze.setObjectName("frame_analyze")
+        self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.frame_analyze)
+        self.verticalLayout_6.setObjectName("verticalLayout_6")
+        spacerItem2 = QtWidgets.QSpacerItem(
+            20, 10, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_6.addItem(spacerItem2)
+        self.label_integration_window = QtWidgets.QLabel(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.PlaceholderText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.PlaceholderText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.PlaceholderText, brush)
+        self.label_integration_window.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.label_integration_window.setFont(font)
+        self.label_integration_window.setObjectName("label_integration_window")
+        self.verticalLayout_6.addWidget(self.label_integration_window)
+        self.rB_1ms = QtWidgets.QRadioButton(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.rB_1ms.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.rB_1ms.setFont(font)
+        self.rB_1ms.setObjectName("rB_1ms")
+        self.rB_1ms.setChecked(True)
+        self.verticalLayout_6.addWidget(self.rB_1ms)
+        self.rB_5ms = QtWidgets.QRadioButton(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.rB_5ms.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.rB_5ms.setFont(font)
+        self.rB_5ms.setObjectName("rB_5ms")
+        self.verticalLayout_6.addWidget(self.rB_5ms)
+        self.rB_10ms = QtWidgets.QRadioButton(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.rB_10ms.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.rB_10ms.setFont(font)
+        self.rB_10ms.setObjectName("rB_10ms")
+        self.verticalLayout_6.addWidget(self.rB_10ms)
+        spacerItem3 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_6.addItem(spacerItem3)
+        self.label_analysis_length = QtWidgets.QLabel(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.PlaceholderText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.PlaceholderText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(0, 0, 0, 128))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.PlaceholderText, brush)
+        self.label_analysis_length.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.label_analysis_length.setFont(font)
+        self.label_analysis_length.setObjectName("label_analysis_length")
+        self.verticalLayout_6.addWidget(self.label_analysis_length)
+        self.lineEdit_aLength = QtWidgets.QLineEdit(self.frame_analyze)
+        self.lineEdit_aLength.setText("100")
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(10)
+        self.lineEdit_aLength.setFont(font)
+        self.lineEdit_aLength.setStyleSheet(
+            "background-color: rgb(255, 255, 255);\n" "\n" ""
+        )
+        self.lineEdit_aLength.setObjectName("lineEdit_aLength")
+        self.verticalLayout_6.addWidget(self.lineEdit_aLength)
+        spacerItem4 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_6.addItem(spacerItem4)
+        self.label_threshold = QtWidgets.QLabel(self.frame_analyze)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.label_threshold.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(12)
+        self.label_threshold.setFont(font)
+        self.label_threshold.setObjectName("label_threshold")
+        self.verticalLayout_6.addWidget(self.label_threshold)
+        self.lineEdit_threshold = QtWidgets.QLineEdit(self.frame_analyze)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(10)
+        self.lineEdit_threshold.setFont(font)
+        self.lineEdit_threshold.setStyleSheet(
+            "background-color: rgb(255, 255, 255);\n" "\n" ""
+        )
+        self.lineEdit_threshold.setText("60")
+        self.lineEdit_threshold.setObjectName("lineEdit_threshold")
+        self.verticalLayout_6.addWidget(self.lineEdit_threshold)
+        spacerItem5 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_6.addItem(spacerItem5)
+        self.verticalLayout_5.addWidget(self.frame_analyze)
+        self.pb_analyze = QtWidgets.QPushButton(self.frame_settings)
+        self.pb_analyze.setMinimumSize(QtCore.QSize(100, 40))
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(14)
+        self.pb_analyze.setFont(font)
+        self.pb_analyze.setStyleSheet(
+            "QPushButton{\n"
+            "    border: 2px solid rgb(69, 113, 213);\n"
+            "    border-radius: 10px;\n"
+            "    background: rgb(69, 113, 213);\n"
+            "    color: rgb(255, 255, 255)\n"
+            "}\n"
+            "QPushButton:hover{\n"
+            "    border: rgb(96, 133, 213);\n"
+            "    background: rgb(96, 133, 213);\n"
+            "}"
+        )
+        self.pb_analyze.setObjectName("pb_analyze")
+        self.verticalLayout_5.addWidget(self.pb_analyze)
+        self.verticalLayout_7.addWidget(self.frame_settings)
+        spacerItem6 = QtWidgets.QSpacerItem(
+            277, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem6)
+        spacerItem7 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem7)
+        spacerItem8 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem8)
+        spacerItem9 = QtWidgets.QSpacerItem(
+            40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem9)
+        spacerItem10 = QtWidgets.QSpacerItem(
+            277, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.verticalLayout_7.addItem(spacerItem10)
+        self.horizontalLayout.addWidget(self.frame_inputs)
+        self.frame_graphics = QtWidgets.QFrame(self.tab_main)
+        self.frame_graphics.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_graphics.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_graphics.setObjectName("frame_graphics")
+        self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.frame_graphics)
+        self.verticalLayout_4.setContentsMargins(-1, 0, 0, 0)
+        self.verticalLayout_4.setObjectName("verticalLayout_4")
+        self.frame_hedgehog = QtWidgets.QFrame(self.frame_graphics)
+        self.frame_hedgehog.setMinimumSize(QtCore.QSize(0, 400))
+        self.frame_hedgehog.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_hedgehog.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_hedgehog.setObjectName("frame_hedgehog")
+        self.verticalLayout_8 = QtWidgets.QVBoxLayout(self.frame_hedgehog)
+        self.verticalLayout_8.setContentsMargins(0, 0, 0, 0)
+        self.verticalLayout_8.setObjectName("verticalLayout_8")
+        self.frame_hedgehog_label = QtWidgets.QFrame(self.frame_hedgehog)
+        self.frame_hedgehog_label.setMaximumSize(QtCore.QSize(16777215, 42))
+        self.frame_hedgehog_label.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_hedgehog_label.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_hedgehog_label.setObjectName("frame_hedgehog_label")
+        self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.frame_hedgehog_label)
+        self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout_2.setObjectName("horizontalLayout_2")
+        spacerItem11 = QtWidgets.QSpacerItem(
+            430, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.horizontalLayout_2.addItem(spacerItem11)
+        self.label_hedgehog = QtWidgets.QLabel(self.frame_hedgehog_label)
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(69, 113, 213))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(69, 113, 213))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
+        brush = QtGui.QBrush(QtGui.QColor(120, 120, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(49, 52, 56))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
+        self.label_hedgehog.setPalette(palette)
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(15)
+        self.label_hedgehog.setFont(font)
+        self.label_hedgehog.setAlignment(QtCore.Qt.AlignCenter)
+        self.label_hedgehog.setObjectName("label_hedgehog")
+        self.horizontalLayout_2.addWidget(self.label_hedgehog)
+        spacerItem12 = QtWidgets.QSpacerItem(
+            429, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.horizontalLayout_2.addItem(spacerItem12)
+        self.verticalLayout_8.addWidget(self.frame_hedgehog_label)
+        self.frame_hedgehog_plot = QtWidgets.QFrame(self.frame_hedgehog)
+        self.frame_hedgehog_plot.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_hedgehog_plot.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_hedgehog_plot.setObjectName("frame_hedgehog_plot")
+        self.gV_hedgehog = QtWebEngineWidgets.QWebEngineView(self.frame_hedgehog_plot)
+        self.gV_hedgehog.setGeometry(QtCore.QRect(0, 0, 1558, 900))
+        self.gV_hedgehog.setStyleSheet("background-color: #313438")
+        self.gV_hedgehog.setObjectName("gV_hedgehog")
+        self.verticalLayout_8.addWidget(self.frame_hedgehog_plot)
+        self.verticalLayout_4.addWidget(self.frame_hedgehog)
+        self.horizontalLayout.addWidget(self.frame_graphics)
+        self.tabWidget.addTab(self.tab_main, "")
+        self.tab_plan = QtWidgets.QWidget()  # acá empieza la tab 2
+        self.tab_plan.setObjectName("tab_plan")
+        self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.tab_plan)
+        self.verticalLayout_3.setObjectName("verticalLayout_3")
+        self.frame_tab_plan = QtWidgets.QFrame(self.tab_plan)
+        self.frame_tab_plan.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_tab_plan.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_tab_plan.setObjectName("frame_tab_plan")
+        self.verticalLayout_10 = QtWidgets.QVBoxLayout(self.frame_tab_plan)
+        self.verticalLayout_10.setObjectName("verticalLayout_10")
+        self.frame_plan_header = QtWidgets.QFrame(self.frame_tab_plan)
+        self.frame_plan_header.setMaximumSize(QtCore.QSize(16777215, 60))
+        self.frame_plan_header.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_plan_header.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_plan_header.setObjectName("frame_plan_header")
+        self.frame_logo_plan = QtWidgets.QFrame(self.frame_plan_header)
+        self.frame_logo_plan.setGeometry(QtCore.QRect(-10, 0, 201, 101))
+        self.frame_logo_plan.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_logo_plan.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_logo_plan.setObjectName("frame_logo_plan")
+        self.label_logo_plan = QtWidgets.QLabel(self.frame_logo_plan)
+        self.label_logo_plan.setGeometry(QtCore.QRect(30, 20, 141, 41))
+        self.label_logo_plan.setText("")
+        self.label_logo_plan.setPixmap(
+            QtGui.QPixmap(str(Path("docs/images/aira-logo.png")))
+        )
+        self.label_logo_plan.setScaledContents(True)
+        self.label_logo_plan.setObjectName("label_logo_plan")
+        self.verticalLayout_10.addWidget(self.frame_plan_header)
+        self.frame_view = QtWidgets.QFrame(self.frame_tab_plan)
+        self.frame_view.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_view.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_view.setObjectName("frame_view")
+        self.horizontalLayout_5 = QtWidgets.QHBoxLayout(self.frame_view)
+        self.horizontalLayout_5.setObjectName("horizontalLayout_5")
+        self.frame_plan_view = QtWidgets.QFrame(self.frame_view)
+        self.frame_plan_view.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_plan_view.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_plan_view.setObjectName("frame_plan_view")
+        self.horizontalLayout_6 = QtWidgets.QHBoxLayout(self.frame_plan_view)
+        self.horizontalLayout_6.setObjectName("horizontalLayout_6")
+        self.label_plan_view = QtWidgets.QLabel(self.frame_plan_view)
+        self.label_plan_view.setText("")
+        self.label_plan_view.setObjectName("label_plan_view")
+        self.label_plan_view.setAlignment(Qt.AlignCenter)
+        pixmap = QPixmap(str(Path("docs/images/aira-banner.png")))
+        self.label_plan_view.setPixmap(
+            pixmap.scaled(750, 3000, aspectRatioMode=Qt.KeepAspectRatio)
+        )
+        # self.label_plan_view.addWidget(self.label_plan_view)
+        self.horizontalLayout_6.addWidget(self.label_plan_view)
+        self.horizontalLayout_5.addWidget(self.frame_plan_view)
+        self.verticalLayout_10.addWidget(self.frame_view)
+        self.frame_plan_footer = QtWidgets.QFrame(self.frame_tab_plan)
+        self.frame_plan_footer.setMaximumSize(QtCore.QSize(16777215, 60))
+        self.frame_plan_footer.setFrameShape(QtWidgets.QFrame.StyledPanel)
+        self.frame_plan_footer.setFrameShadow(QtWidgets.QFrame.Raised)
+        self.frame_plan_footer.setObjectName("frame_plan_footer")
+        self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.frame_plan_footer)
+        self.horizontalLayout_4.setObjectName("horizontalLayout_4")
+        spacerItem15 = QtWidgets.QSpacerItem(
+            265, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.horizontalLayout_4.addItem(spacerItem15)
+        self.pB_load_plan = QtWidgets.QPushButton(self.frame_plan_footer)
+        self.pB_load_plan.setMinimumSize(QtCore.QSize(171, 40))
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(14)
+        self.pB_load_plan.setFont(font)
+        self.pB_load_plan.setStyleSheet(
+            "QPushButton{\n"
+            "    border: 2px solid rgb(69, 113, 213);\n"
+            "    border-radius: 10px;\n"
+            "    background: rgb(69, 113, 213);\n"
+            "    color: rgb(255, 255, 255)\n"
+            "}\n"
+            "QPushButton:hover{\n"
+            "    border: rgb(96, 133, 213);\n"
+            "    background: rgb(96, 133, 213);\n"
+            "}\n"
+            ""
+        )
+        self.pB_load_plan.setObjectName("pushButton")
+        self.horizontalLayout_4.addWidget(self.pB_load_plan)
+        spacerItem16 = QtWidgets.QSpacerItem(
+            382, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.horizontalLayout_4.addItem(spacerItem16)
+        self.pB_export_plan = QtWidgets.QPushButton(self.frame_plan_footer)
+        self.pB_export_plan.setEnabled(False)
+        self.pB_export_plan.setMinimumSize(QtCore.QSize(171, 40))
+        font = QtGui.QFont()
+        font.setFamily("Lato")
+        font.setPointSize(14)
+        self.pB_export_plan.setFont(font)
+        self.pB_export_plan.setStyleSheet(
+            "QPushButton{\n"
+            "    border: 2px solid rgb(69, 76, 93);\n"
+            "    border-radius: 10px;\n"
+            "    background: rgb(69, 76, 93);\n"
+            "    color: rgb(255, 255, 255)\n"
+            "}\n"
+            "QPushButton:hover{\n"
+            "    border: rgb(96, 133, 213);\n"
+            "    background: rgb(96, 133, 213);\n"
+            "}"
+        )
+        self.pB_export_plan.setObjectName("pB_export_plan")
+        self.horizontalLayout_4.addWidget(self.pB_export_plan)
+        spacerItem17 = QtWidgets.QSpacerItem(
+            265, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum
+        )
+        self.horizontalLayout_4.addItem(spacerItem17)
+        self.verticalLayout_10.addWidget(self.frame_plan_footer)
+        self.verticalLayout_3.addWidget(self.frame_tab_plan)
+        self.tabWidget.addTab(self.tab_plan, "")
+        self.verticalLayout_2.addWidget(self.tabWidget)
+        self.verticalLayout.addWidget(self.frame_main)
+        MainWindow.setCentralWidget(self.centralwidget)
+        self.menubar = QtWidgets.QMenuBar(MainWindow)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 1350, 21))
+        self.menubar.setObjectName("menubar")
+        self.menuFile = QtWidgets.QMenu(self.menubar)
+        self.menuFile.setObjectName("menuFile")
+        self.menuImport = QtWidgets.QMenu(self.menuFile)
+        self.menuImport.setObjectName("menuImport")
+        self.menuImport_A_format = QtWidgets.QMenu(self.menuImport)
+        self.menuImport_A_format.setObjectName("menuImport_A_format")
+        self.menuImport_B_format = QtWidgets.QMenu(self.menuImport)
+        self.menuImport_B_format.setObjectName("menuImport_B_format")
+        self.menuExport = QtWidgets.QMenu(self.menuFile)
+        self.menuExport.setObjectName("menuExport")
+        MainWindow.setMenuBar(self.menubar)
+        self.statusbar = QtWidgets.QStatusBar(MainWindow)
+        self.statusbar.setObjectName("statusbar")
+        MainWindow.setStatusBar(self.statusbar)
+
+        self.actionImport_Aformat_1channel = QtWidgets.QAction(MainWindow)
+        self.actionImport_Aformat_1channel.setObjectName(
+            "actionImport_Aformat_1channel"
+        )
+        self.actionImport_Aformat_4channels = QtWidgets.QAction(MainWindow)
+        self.actionImport_Aformat_4channels.setObjectName(
+            "actionImport_Aformat_4channels"
+        )
+        self.actionImport_Bformat_1channel = QtWidgets.QAction(MainWindow)
+        self.actionImport_Bformat_1channel.setObjectName(
+            "actionImport_Bformat_1channel"
+        )
+        self.actionImport_Bformat_4channels = QtWidgets.QAction(MainWindow)
+        self.actionImport_Bformat_4channels.setObjectName(
+            "actionImport_Bformat_4channels"
+        )
+        self.actionImport_LSS = QtWidgets.QAction(MainWindow)
+        self.actionImport_LSS.setObjectName("actionImport_LSS")
+        self.actionExport_hedgehog_plot = QtWidgets.QAction(MainWindow)
+        self.actionExport_hedgehog_plot.setObjectName("actionExport_hedgehog_plot")
+
+        self.menuImport_A_format.addAction(self.actionImport_Aformat_1channel)
+        self.menuImport_A_format.addAction(self.actionImport_Aformat_4channels)
+        self.menuImport_B_format.addAction(self.actionImport_Bformat_1channel)
+        self.menuImport_B_format.addAction(self.actionImport_Bformat_4channels)
+        self.menuImport.addAction(self.actionImport_LSS)
+        self.menuExport.addAction(self.actionExport_hedgehog_plot)
+
+        self.menuFile.addAction(self.menuImport.menuAction())
+        self.menuImport.addAction(self.menuImport_A_format.menuAction())
+        self.menuImport.addAction(self.menuImport_B_format.menuAction())
+        self.menuFile.addAction(self.menuExport.menuAction())
+        self.menubar.addAction(self.menuFile.menuAction())
+
+        self.retranslateUi(MainWindow)
+        self.tabWidget.setCurrentIndex(0)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+        # CONEXIONES DE GUI CON ACCIONES
+
+        # Creo los labels para guardar la data que devuelven las funciones de import triggereadas
+        self.path_1 = QLabel()
+        self.path_2 = QLabel()
+        self.path_3 = QLabel()
+        self.path_4 = QLabel()
+        self.path_5 = QLabel()
+        self.input_mode_selected = QLabel()
+        self.channels_per_file_selected = QLabel()
+
+        self.actionImport_LSS.triggered.connect(self.import_LSS)
+        self.actionImport_Aformat_1channel.triggered.connect(
+            self.import_Aformat_1channel
+        )
+        self.actionImport_Aformat_4channels.triggered.connect(
+            self.import_Aformat_4channels
+        )
+        self.actionImport_Bformat_1channel.triggered.connect(
+            self.import_Bformat_1channel
+        )
+        self.actionImport_Bformat_4channels.triggered.connect(
+            self.import_Bformat_4channels
+        )
+
+        self.pb_analyze.clicked.connect(self.analyze)
+        self.pB_load_plan.clicked.connect(self.load_plan)
+        self.pB_export_plan.clicked.connect(self.export_plan)
+
+    def retranslateUi(self, MainWindow):
+        _translate = QtCore.QCoreApplication.translate
+        MainWindow.setWindowTitle(
+            _translate("MainWindow", "Ambisonics Impulse Response Analyzer")
+        )
+        self.label_integration_window.setText(
+            _translate("MainWindow", "Integration Window:")
+        )
+        self.rB_1ms.setText(_translate("MainWindow", "1 ms"))
+        self.rB_5ms.setText(_translate("MainWindow", "5 ms"))
+        self.rB_10ms.setText(_translate("MainWindow", "10 ms"))
+        self.label_analysis_length.setText(
+            _translate("MainWindow", "Analysis Length [ms]")
+        )
+        self.label_threshold.setText(_translate("MainWindow", "Threshold [dB]"))
+        self.pb_analyze.setText(_translate("MainWindow", "Analyze"))
+        self.label_hedgehog.setText(_translate("MainWindow", "Hedgehog Plot"))
+        self.tabWidget.setTabText(
+            self.tabWidget.indexOf(self.tab_main), _translate("MainWindow", "Main")
+        )
+        self.pB_load_plan.setText(_translate("MainWindow", "Load"))
+        self.pB_export_plan.setText(_translate("MainWindow", "Export"))
+        self.tabWidget.setTabText(
+            self.tabWidget.indexOf(self.tab_plan), _translate("MainWindow", "Plan View")
+        )
+        self.menuFile.setTitle(_translate("MainWindow", "File"))
+        self.menuImport.setTitle(_translate("MainWindow", "Import"))
+        self.menuImport_A_format.setTitle(_translate("MainWindow", "A-format"))
+        self.menuImport_B_format.setTitle(_translate("MainWindow", "B-format"))
+        self.menuExport.setTitle(_translate("MainWindow", "Export"))
+        self.actionImport_Aformat_1channel.setText(
+            _translate("MainWindow", "1-channel per file")
+        )
+        self.actionImport_Aformat_4channels.setText(
+            _translate("MainWindow", "4-channels per file")
+        )
+        self.actionImport_Bformat_1channel.setText(
+            _translate("MainWindow", "1-channel per file")
+        )
+        self.actionImport_Bformat_4channels.setText(
+            _translate("MainWindow", "4-channels per file")
+        )
+        self.actionImport_LSS.setText(
+            _translate("MainWindow", "LSS with inverse filter")
+        )
+        self.actionExport_hedgehog_plot.setText(
+            _translate("MainWindow", "Hedgehog plot")
+        )
+
+    # Acá empiezan los métodos para las acciones del usuario
+
+    def analyze(self):
+        if self.input_mode_selected.text() == "LSS":
+            input_mode = InputMode.LSS
+            FLU_path = self.path_1.text()
+            FRD_path = self.path_2.text()
+            BRU_path = self.path_3.text()
+            BLD_path = self.path_4.text()
+            IF_path = self.path_5.text()
+            channels_per_file = 1
+            data = {
+                "front_left_up": FLU_path,
+                "front_right_down": FRD_path,
+                "back_right_up": BRU_path,
+                "back_left_down": BLD_path,
+                "inverse_filter": IF_path,
+                "input_mode": input_mode,
+                "channels_per_file": channels_per_file,
+                "frequency_correction": True,
+            }
+        elif self.input_mode_selected.text() == "AFORMAT":
+            input_mode = InputMode.AFORMAT
+            if self.channels_per_file_selected.text() == "1":
+                FLU_path = self.path_1.text()
+                FRD_path = self.path_2.text()
+                BRU_path = self.path_3.text()
+                BLD_path = self.path_4.text()
+                channels_per_file = 1
+                data = {
+                    "front_left_up": FLU_path,
+                    "front_right_down": FRD_path,
+                    "back_right_up": BRU_path,
+                    "back_left_down": BLD_path,
+                    "input_mode": input_mode,
+                    "channels_per_file": channels_per_file,
+                    "frequency_correction": True,
+                }
+            else:
+                A4_path = self.path_1.text()
+                channels_per_file = 4
+                data = {
+                    "stacked_signals": A4_path,
+                    "input_mode": input_mode,
+                    "channels_per_file": channels_per_file,
+                    "frequency_correction": True,
+                }
+        else:
+            input_mode = InputMode.BFORMAT
+            if self.channels_per_file_selected.text() == "1":
+                W_path = self.path_1.text()
+                X_path = self.path_2.text()
+                Y_path = self.path_3.text()
+                Z_path = self.path_4.text()
+                channels_per_file = 1
+                data = {
+                    "channel_w": W_path,
+                    "channel_X": X_path,
+                    "channel_Y": Y_path,
+                    "channel_Z": Z_path,
+                    "input_mode": input_mode,
+                    "channels_per_file": channels_per_file,
+                    "frequency_correction": True,
+                }
+            else:
+                B4_path = self.path_1.text()
+                channels_per_file = 4
+                data = {
+                    "stacked_signals": B4_path,
+                    "input_mode": input_mode,
+                    "channels_per_file": channels_per_file,
+                    "frequency_correction": True,
+                }
+
+        fig = analyzer.analyze(input_dict=data)
+        self.gV_hedgehog.setHtml(fig.to_html(include_plotlyjs="cdn"))
+
+    def load_plan(self):
+        file_dialog = QFileDialog()
+        file_path, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select image", "", "Image file (*.png *.jpg *.jpeg)"
+        )
+        if file_path:
+            pixmap = QPixmap(file_path)
+            self.label_plan_view.setPixmap(
+                pixmap.scaled(750, 3000, aspectRatioMode=Qt.KeepAspectRatio)
+            )
+            self.enable_export()
+
+    def enable_export(self):
+        self.pB_export_plan.setEnabled(True)
+        self.pB_export_plan.setStyleSheet(
+            """
+            QPushButton {
+                border: 2px solid rgb(69, 113, 213);
+                border-radius: 10px;
+                background-color: rgb(69, 113, 213);
+                color: rgb(255, 255, 255);
+            }
+            QPushButton:hover {
+                border: rgb(96, 133, 213);
+                background-color: rgb(96, 133, 213);
+            }
+        """
+        )
+
+    def export_plan(self):
+        file_dialog = QFileDialog()
+        save_path, _ = file_dialog.getSaveFileName(
+            MainWindow, "Export image", "", "Image file (*.png *.jpg *.jpeg)"
+        )
+
+    def import_Aformat_1channel(self):
+        file_dialog = QFileDialog()
+        file_path_FLU, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Front-Left-Up", "", "WAV file (*.wav)"
+        )
+        file_path_FRD, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Front-Right-Down", "", "WAV file (*.wav)"
+        )
+        file_path_BRU, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Back-Right-Up", "", "WAV file (*.wav)"
+        )
+        file_path_BLD, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Back-Left-Down", "", "WAV file (*.wav)"
+        )
+        self.path_1.setText(file_path_FLU)
+        self.path_2.setText(file_path_FRD)
+        self.path_3.setText(file_path_BRU)
+        self.path_4.setText(file_path_BLD)
+        self.input_mode_selected.setText("AFORMAT")
+        self.channels_per_file_selected.setText("1")
+
+    def import_Aformat_4channels(self):
+        file_dialog = QFileDialog()
+        file_path_A4, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select audio file", "", "WAV file (*.wav)"
+        )
+        self.path_1.setText(file_path_A4)
+        self.input_mode_selected.setText("AFORMAT")
+        self.channels_per_file_selected.setText("4")
+
+    def import_Bformat_1channel(self):
+        file_dialog = QFileDialog()
+        file_path_W, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel W", "", "WAV file (*.wav)"
+        )
+        file_path_X, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel X", "", "WAV file (*.wav)"
+        )
+        file_path_Y, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Y", "", "WAV file (*.wav)"
+        )
+        file_path_Z, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Z", "", "WAV file (*.wav)"
+        )
+        self.path_1.setText(file_path_W)
+        self.path_2.setText(file_path_X)
+        self.path_3.setText(file_path_Y)
+        self.path_4.setText(file_path_Z)
+        self.input_mode_selected.setText("BFORMAT")
+        self.channels_per_file_selected.setText("1")
+
+    def import_Bformat_4channels(self):
+        file_dialog = QFileDialog()
+        file_path_B4, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select audio file", "", "WAV file (*.wav)"
+        )
+        self.path_1.setText(file_path_B4)
+        self.input_mode_selected.setText("BFORMAT")
+        self.channels_per_file_selected.setText("4")
+
+    def import_LSS(self):
+        file_dialog = QFileDialog()
+        file_path_FLU, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Front-Left-Up", "", "WAV file (*.wav)"
+        )
+        file_path_FRD, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Front-Right-Down", "", "WAV file (*.wav)"
+        )
+        file_path_BRU, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Back-Right-Up", "", "WAV file (*.wav)"
+        )
+        file_path_BLD, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select channel Back-Left-Down", "", "WAV file (*.wav)"
+        )
+        file_path_IF, _ = file_dialog.getOpenFileName(
+            MainWindow, "Select inverse filter", "", "WAV file (*.wav)"
+        )
+        self.path_1.setText(file_path_FLU)
+        self.path_2.setText(file_path_FRD)
+        self.path_3.setText(file_path_BRU)
+        self.path_4.setText(file_path_BLD)
+        self.path_5.setText(file_path_IF)
+        self.input_mode_selected.setText("LSS")
+        self.channels_per_file_selected.setText("1")
+
+    def export_hedgehog(self):
+        file_dialog = QFileDialog()
+        save_path, _ = file_dialog.getSaveFileName(
+            MainWindow, "Export image", "", "Image file (*.png *.jpg *.jpeg)"
+        )
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QtWidgets.QApplication(sys.argv)
+    MainWindow = QtWidgets.QMainWindow()
+    ui = Ui_MainWindow()
+    ui.setupUi(MainWindow)
+    MainWindow.show()
+    MainWindow.showMaximized()
+    sys.exit(app.exec_())

aira/utils/__init__.py

@@ -0,0 +1,8 @@
+"""Utils module imports."""
+
+from .formatter import (
+    convert_ambisonics_a_to_b,
+    cartesian_to_spherical,
+    spherical_to_cartesian,
+)
+from .utils import read_signals_dict, read_aformat

aira/utils/formatter.py

@@ -0,0 +1,120 @@
+"""3D format conversion for coordinates and Ambisonics"""
+
+from functools import singledispatch
+from typing import List, Tuple, Union
+
+import numpy as np
+
+
+@singledispatch
+def convert_ambisonics_a_to_b(
+    front_left_up: np.ndarray,
+    front_right_down: np.ndarray,
+    back_right_up: np.ndarray,
+    back_left_down: np.ndarray,
+) -> np.ndarray:
+    """Converts Ambisonics A-format to B-format
+
+    Parameters
+    ----------
+    front_left_up : np.ndarray
+            Front Left Up signal from A-format
+    front_right_down : np.ndarray
+        Front Right Down signal from A-format
+    back_right_up : np.ndarray
+        Back Right Up signal from A-format
+    back_left_down : np.ndarray
+        Back Left Down signal from A-format
+
+    Returns
+    -------
+    np.ndarray
+        B-format outputs (W, X, Y, Z)
+    """
+
+    front = front_left_up + front_right_down
+    back = back_left_down + back_right_up
+    left = front_left_up + back_left_down
+    right = front_right_down + back_right_up
+    up = front_left_up + back_right_up  # pylint: disable=invalid-name
+    down = front_right_down + back_left_down
+
+    w_channel = front + back
+    x_channel = front - back
+    y_channel = left - right
+    z_channel = up - down
+
+    return np.array([w_channel, x_channel, y_channel, z_channel])
+
+
+@convert_ambisonics_a_to_b.register(list)
+def _(aformat_channels: List[np.ndarray]) -> np.ndarray:
+    """Converts Ambisonics A-format to B-format.
+
+    Parameters
+    ----------
+    aformat_channels : List[np.ndarray]
+        A list containing the 4 channels of A-format Ambisonics in the following order:
+            1. Front Left Up
+            2. Front Right Down
+            3. Back Right Up
+            4. Back Left Down
+
+    Returns
+    -------
+    np.ndarray
+        B-format outputs (W, X, Y, Z)
+    """
+    assert (
+        len(aformat_channels) == 4
+    ), "Conversion from A-format to B-format requires 4 channels"
+    return convert_ambisonics_a_to_b.dispatch(np.ndarray)(
+        front_left_up=aformat_channels[0],
+        front_right_down=aformat_channels[1],
+        back_right_up=aformat_channels[2],
+        back_left_down=aformat_channels[3],
+    )
+
+
+def spherical_to_cartesian(
+    radius: Union[float, np.ndarray],
+    azimuth: Union[float, np.ndarray],
+    elevation: Union[float, np.ndarray],
+) -> Tuple[Union[float, np.ndarray]]:
+    """Convert three 3D polar coordinates to Cartesian ones.
+
+    Parameters
+        radius: float | np.ndarray. The radii (or rho).
+        azimuth: float | np.ndarray. The azimuth (also called theta or alpha).
+        elevation: float | np.ndarray. The elevation (also called phi or polar).
+
+    Returns
+        (x, y, z): Tuple[float | np.ndarray]. The corresponding Cartesian coordinates.
+    """
+    return (
+        radius * np.cos(np.deg2rad(azimuth)) * np.cos(np.deg2rad(elevation)),
+        radius * np.sin(np.deg2rad(azimuth)) * np.cos(np.deg2rad(elevation)),
+        radius * np.sin(np.deg2rad(elevation)),
+    )
+
+
+def cartesian_to_spherical(intensity_windowed: np.ndarray):
+    """_summary_
+
+    Parameters
+    ----------
+    intensity_windowed : np.ndarray
+        _description_
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    # Convert to total intensity, azimuth and elevation
+    intensity = np.sqrt((intensity_windowed**2).sum(axis=0)).squeeze()
+    azimuth = np.rad2deg(
+        np.arctan2(intensity_windowed[1], intensity_windowed[0])
+    ).squeeze()
+    elevation = np.rad2deg(np.arcsin(intensity_windowed[2] / intensity)).squeeze()
+    return intensity, azimuth, elevation

aira/utils/utils.py

@@ -0,0 +1,180 @@
+"""Audio utilities"""
+
+from functools import singledispatch
+from pathlib import Path
+from traceback import print_exc
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import soundfile as sf
+
+
+def read_signals_dict(signals_dict: dict) -> dict:
+    """Read the signals contained in signals_dict and overwrites the paths with the arrays.
+
+    Parameters
+    ----------
+    signals_dict : dict
+        Dictionary with signals path.
+
+    Returns
+    -------
+    dict
+        Same signals_dict dictionary with the signals array overwritting signals path.
+    """
+    for key_i, path_i in signals_dict.items():
+        try:
+            signal_i, sample_rate = sf.read(path_i)
+            signals_dict[key_i] = signal_i.T
+        except:
+            pass
+
+    signals_dict["sample_rate"] = sample_rate
+
+    if signals_dict["channels_per_file"] == 1:
+        if signals_dict["input_mode"] == "bformat":
+            bformat_keys = ["w_channel", "x_channel", "y_channel", "z_channel"]
+            signals_dict["stacked_signals"] = stack_dict_arrays(
+                signals_dict, bformat_keys
+            )
+        else:
+            aformat_keys = [
+                "front_left_up",
+                "front_right_down",
+                "back_right_up",
+                "back_left_down",
+            ]
+            signals_dict["stacked_signals"] = stack_dict_arrays(
+                signals_dict, aformat_keys
+            )
+
+    return signals_dict
+
+
+def stack_dict_arrays(signals_dict_array: dict, keys: List[str]) -> np.ndarray:
+    """Stacks arrays into single numpy.ndarray object given the dictionary and the keys
+    to be stacked.
+
+    Parameters
+    ----------
+    signals_dict_array : dict
+        Dictionary containing the arrays to be stacked
+    keys : List[str]
+        Keys of signals_dict_array with the arrays to be stacked
+
+    Returns
+    -------
+    np.ndarray
+        Stacked arrays into single numpy.ndarray object
+    """
+    audio_array = []
+    for key_i in keys:
+        audio_array.append(signals_dict_array[key_i])
+
+    return audio_array
+
+
+@singledispatch
+def read_aformat(audio_path: Union[str, Path]) -> Tuple[np.ndarray, float]:
+    """Read an A-format Ambisonics signal from a single audio path, which is expected
+    to contain 4 channels.
+
+    Parameters
+    ----------
+    audio_paths : str | Path
+        Strings containing the audio paths to be loaded
+
+    Returns
+    -------
+    Tuple[np.ndarray, float]
+        Sample rate of the audios and audios loaded as rows of a np.ndarray
+    """
+    signal, sample_rate = sf.read(audio_path)
+    signal = signal.T
+    assert signal.shape[0] == 4, (
+        f"Audio file {str(audio_path)} with shape {signal.shape} does not"
+        f"contain 4 channels, so it cannot be A-format Ambisonics"
+    )
+    return signal, sample_rate
+
+
+@read_aformat.register(list)
+def _(audio_paths: List[str]) -> Tuple[np.ndarray, float]:
+    """Read an A-format Ambisonics signal from audio paths. 4 paths are expected,
+    one for each cardioid signal, in the following order:
+        1. front left up
+        2. front right down
+        3. back right up
+        4. back left down
+
+    Parameters
+    ----------
+    audio_paths : List[str]
+        Strings containing the audio paths to be loaded
+
+    Returns
+    -------
+    Tuple[np.ndarray, float]
+        Sample rate of the audios and audios loaded as rows of a np.ndarray
+    """
+    assert (isinstance(audio_paths, (str, Path, list))) or (
+        len(audio_paths) in (1, 4)
+    ), "One wave file with 4 channels or a list of 4 wave files is expected"
+
+    audio_array = []
+    for audio_i in audio_paths:
+        try:
+            audio_array_i, sample_rate = sf.read(audio_i)
+            audio_array.append(audio_array_i)
+        except sf.SoundFileError:
+            print_exc()
+
+    return np.array(audio_array), sample_rate
+
+
+@read_aformat.register(dict)
+def _(audio_paths: Dict[str, str]) -> Tuple[np.ndarray, float]:
+    """Read an A-format Ambisonics signal from a dictionary with audio paths. 4 keys are expected,
+    one for each cardioid signal:
+        1. front_left_up
+        2. front_right_down
+        3. back_right_up
+        4. back_left_down
+
+    Parameters
+    ----------
+    audio_paths : Dict[str]
+        Key-value pair containing the audio paths to be loaded for each FLU/FRD/BRU/BLD channel
+
+    Returns
+    -------
+    Tuple[np.ndarray, float]
+        Sample rate of the audios and audios loaded as rows of a np.ndarray
+    """
+    ordered_aformat_channels = (
+        "front_left_up",
+        "front_right_down",
+        "back_right_up",
+        "back_left_down",
+    )  # Assert the ordering is standardized across the project
+    try:
+        audio_data = {
+            cardioid_channel: dict(zip(("signal", "sample_rate"), sf.read(path)))
+            for cardioid_channel, path in audio_paths.items()
+        }
+
+        # refactor from here
+        audio_signals = [
+            audio_data[channel_name]["signal"]
+            for channel_name in ordered_aformat_channels
+        ]
+        sample_rates = [
+            audio_data[channel_name]["sample_rate"]
+            for channel_name in ordered_aformat_channels
+        ]
+        assert len(set(sample_rates)) == 1, "Multiple different sample rates were found"
+
+        signals_array = np.array(audio_signals)
+        return signals_array, sample_rates[0]
+    except sf.SoundFileError:
+        print_exc()

app.py

@@ -0,0 +1,82 @@
+import streamlit as st
+import plotly.graph_objects as go
+from aira.core import AmbisonicsImpulseResponseAnalyzer
+from aira.engine.input import InputMode
+import os
+import tempfile
+
+
+def save_temp_file(file):
+    temp_dir = tempfile.gettempdir()
+    temp_file_path = os.path.join(temp_dir, file.name)
+    with open(temp_file_path, "wb") as temp_file:
+        temp_file.write(file.getvalue())
+    return temp_file_path
+
+
+def run_streamlit_app():
+    st.set_page_config(
+        page_title="AIRA", page_icon="docs/images/aira-icon.png", layout="wide"
+    )
+
+    # Logo
+    logo_path = "docs/images/aira-banner.png"
+    personal_logo_path = "docs/images/nahue-passano.png"
+    st.columns(11)[10].image(personal_logo_path, use_column_width=True)
+    st.columns(3)[1].image(logo_path, use_column_width=True)
+
+    # Audio loading and settings
+
+    audio_files, settings = st.columns(2)
+
+    with audio_files:
+        st.header("🔉 LSS room responses in A-Format")
+        up_files, down_files = st.columns(2)
+
+        with up_files:
+            audio_file_flu = st.file_uploader("Front-Left-Up", type=["mp3", "wav"])
+            audio_file_bru = st.file_uploader("Back-Right-Up", type=["mp3", "wav"])
+
+        with down_files:
+            audio_file_frd = st.file_uploader("Front-Right-Down", type=["mp3", "wav"])
+            audio_file_bld = st.file_uploader("Back-Left-Down", type=["mp3", "wav"])
+
+        audio_file_inverse_filter = st.file_uploader(
+            "Inverse filter", type=["mp3", "wav"]
+        )
+
+    with settings:
+        st.header("⚙️ Settings")
+        integration_time = st.selectbox("Integration time [ms]", [1, 5, 10])
+        analysis_length = st.text_input("Analysis length [ms]", value="500")
+        intensity_threshold = st.text_input("Intensity threshold [dB]", value=-60)
+
+        # "Analyze" button
+        if st.button("Analyze", use_container_width=True):
+            data = {
+                "front_left_up": save_temp_file(audio_file_flu),
+                "front_right_down": save_temp_file(audio_file_frd),
+                "back_right_up": save_temp_file(audio_file_bru),
+                "back_left_down": save_temp_file(audio_file_bld),
+                "inverse_filter": save_temp_file(audio_file_inverse_filter),
+                "input_mode": InputMode.LSS,
+                "channels_per_file": 1,
+                "frequency_correction": True,
+            }
+
+            analyzer = AmbisonicsImpulseResponseAnalyzer(
+                int(integration_time),
+                float(intensity_threshold),
+                float(analysis_length),
+            )
+            fig = analyzer.analyze(data, show=False)
+            fig.update_layout(height=1080)
+            st.plotly_chart(fig, use_container_width=True, height=1080)
+
+            # Generar un gráfico genérico con Plotly
+            fig = go.Figure(data=go.Scatter(x=[1, 2, 3, 4], y=[10, 5, 7, 2]))
+            st.plotly_chart(fig)
+
+
+if __name__ == "__main__":
+    run_streamlit_app()

pyproject.toml

@@ -0,0 +1,33 @@
+[tool.poetry]
+name = "aira"
+version = "0.1.0"
+description = "3D Ambisonics Impulse Response Analyzer"
+authors = [
+    "Ivan Pupkin <[email protected]>",
+    "Nahuel Passano <[email protected]>"
+]
+
+[tool.poetry.dependencies]
+python = ">=3.8,<3.9.7 || >3.9.7,<3.11"
+numpy = "^1.24.3"
+librosa = "^0.10.0"
+scipy = "^1.10.1"
+soundfile = "^0.12.1"
+plotly = "^5.14.1"
+pandas = "^2.0.1"
+kaleido = "0.2.1"
+matplotlib = "^3.7.1"
+pyqt5 = "^5.15.9"
+pyqtwebengine = "^5.15.6"
+streamlit = "^1.24.0"
+
+
+[tool.poetry.dev-dependencies]
+black = "^23.3.0"
+pylint = "^2.17.3"
+pytest = "^7.3.1"
+pre-commit = "^3.2.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,11 @@
+numpy==1.24.3
+librosa==0.10.0
+scipy==1.10.1
+soundfile==0.12.1
+plotly==5.14.1
+pandas==2.0.1
+kaleido == 0.2.1
+matplotlib==3.7.1
+pyqt5==5.15.9
+pyqtwebengine==5.15.6
+streamlit==1.24.0