Rolling out DB v72

Docs updated
Rolling out v4.1.0
2025-05-04 21:55:43 +02:00 · 2024-10-25 00:15:29 +02:00 · 2024-10-20 20:38:41 +02:00 · 2024-10-20 20:00:33 +02:00 · 2024-10-20 19:59:39 +02:00 · 2024-10-20 19:47:27 +02:00
284 changed files with 17949 additions and 29773 deletions
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -0,0 +1,32 @@
+name: Nuitka - Linux 
+
+on:
+  workflow_dispatch:
+    inputs:
+      artemis_version:
+        description: 'Version'
+        required: true
+        default: '4.1.0'
+        type: string
+
+jobs:
+  build-linux-x86_64:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Build and package
+        run: sh ./building/Linux/build_linux.sh
+        shell: bash
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Artemis-Linux-x86_64-${{github.event.inputs.artemis_version}}
+          path: ./app.dist/
--- a/.github/workflows/macOS.yml
+++ b/.github/workflows/macOS.yml
@@ -0,0 +1,32 @@
+name: Nuitka - macOS 
+
+on:
+  workflow_dispatch:
+    inputs:
+      artemis_version:
+        description: 'Version'
+        required: true
+        default: '4.1.0'
+        type: string
+
+jobs:
+  build-macos-x86_64:
+    runs-on: macos-12
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Build and package
+        run: sh ./building/macOS/build_macos.sh
+        shell: bash
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Artemis-macOS-x86_64-${{github.event.inputs.artemis_version}}
+          path: ./app.dist/
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,35 @@
+name: Nuitka - Windows 
+
+on:
+  workflow_dispatch:
+    inputs:
+      artemis_version:
+        description: 'Version'
+        required: true
+        default: '4.1.0'
+        type: string
+
+jobs:
+  build-windows-x86_64:
+    runs-on: windows-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Build and package
+        run: ./building/Windows/build_windows.ps1
+        shell: powershell
+
+      - name: Building installer (ISCC)
+        run: iscc ./building/Windows/windows_installer.iss
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Artemis-Windows-x86_64-${{github.event.inputs.artemis_version}}
+          path: ./building/artemis.exe
--- a/.gitignore
+++ b/.gitignore
@@ -1,11 +1,11 @@
-__PYCache__
-Data
-src/themes/__current_theme
-designer.bat
-launch.bat
+**/__pycache__/
 .vscode/
-.code-workspace
-spec_files/**/output
-*.txt
-*.json
-info.log
+*.pyproject.user
+data/
+.flake8
+*.qtds
+artemis_rc.py
+site
+Generated
+app.build
+app.dist
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,85 @@
 # Changelog
-This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

-The first release is [3.0.0] because this is actually the third major version (completely rewritten) of the software.
+> [!NOTE]  
+> This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
+
+## [4.1.0] - 2024-10-20
+
+### Added
+- Created a setting panel for the audio player
+- Selection of the audio output device. Closes [#4](https://github.com/AresValley/Artemis/issues/4)
+- Added the following (advanced) products to the space weather module. Closes [#53](https://github.com/AresValley/Artemis/issues/53):
+  - Sun Synoptic Analysis (SAS)
+  - GOES Solar Ultraviolet Imager (SUVI), all wavelenght (94 Å, 131 Å, 171 Å, 195 Å, 284 Å, 304 Å)
+  - GOES Thematic Map (from SUVI)
+  - Large Angle and Spectrometric Coronagraph (LASCO), both C2/C3 range for optical imaging of the Sun’s corona
+  - Helioseismic and Magnetic Imager (HMI): Magnetogram, Intensitygram, Dopplergram
+
+### Fixed
+- Fixed margins for downloader window
+
+## [4.0.5] - 2024-06-15
+
+### Added
+- Possibility to navigate Artemis just with the keyboard [#50](https://github.com/AresValley/Artemis/issues/50)
+- **Windows:** automatic updates have been implemented. When a software update is available, Artemis will download the new version and install the updates automatically 
+- Multiple sigID databases can be conserved. In the case of autoload, the latest local version will be loaded
+- Added creation date and DB version in DB manager window
+
+### Changed
+- Improved readability of labels for filter ranges for frequency, bandwidth, and ACF
+- Improved Update manager and Downloader functionalities
+- OS-dependent temporary folders are now used for database download and Artemis updates
+- The logic for searching the last sigID database has changed now the discriminant is no longer the folder name but is reported as a signature in the database itself (-1 in the editable field; see documentation)
+- Old sigID databases are not deleted anymore when a new version is downloaded. This is to avoid removing databases with user changes or additions
+
+### Fixed
+- Added a database load check to avoid (noncritical) exceptions when applying filters without having loaded a database.
+- Fixed a potential issue involving the forcible closure of the downloader window, but the downloader instance keeps running
+- With the new logic in the latest sigID database search, manually imported sigID databases are officially recognized as proper ones
+
+## [4.0.3] - 2024-06-10
+
+### Changed
+- Optimized final package size (reduced by 30% to 50%) by explicitly including necessary plugins/DLLs and excluding unnecessary ones with Nuitka [#47](https://github.com/AresValley/Artemis/issues/47)
+
+### Fixed
+- When the links/urls in the description field of a signal are clicked, they open the default browser [#46](https://github.com/AresValley/Artemis/issues/46)
+- Fixed an error occurig on Linux where configuration file path are not properly resolved during startup with the binary version of the program (they are if running from source) [#48](https://github.com/AresValley/Artemis/issues/48)
+
+## [4.0.1] - 2024-06-9
+### Added
+- Database format has been changed from .csv to a proper relational DB (sqlite) which is much easier handled thanks to the native library shipped with python
+- Possibility to create an arbitrary number of new databases for storing new custom signals
+- Every signal allows an arbitrary number of parameters
+- All signal parameters (such as frequency, modulation, location, etc.) are now followed by a description
+- Databases can be exported/imported for easy sharing
+- Possibility to store and view all type of documents related to a signal entry
+- Filtration process is now much more efficient due to usage of SQL queries
+- D-Region Absorption Predictions (DRAP) and Aurora OVATION model are now present in the Space Weather window
+
+### Changed
+- Updated GUI libray from PyQt5 to PySide6. Artemis 4 now relies on the QtQuick framework.
+- SigID standard database is now hosted on GitHub (the server is much faster) along with the website parser
+- Undefined value for frequency and bandwidth is now deprecated
+- Drastically reduced the number of third party libraries
+- The signals filtering page has been simplified to be more immediate and user friendly
+- Space weather page has been greatly improved and now relies on Poseidon daemon (hosted on aresvalley.com)
+
+### Fixed
+- Artemis can be execunted inside standard pretected folder (such as Program Files) without using elevated privileges
+
+## [3.2.4] - 2022-09-30
+### Fixed
+- Fixed crash on opening the Rx/Tx Condition tab
+
+## [3.2.3] - 2022-09-29
+### Added
+- Add auto-packaging feature using GitHub actions for Windows OS (experimental)
+### Fixed
+- Fix crash for playing audio ([#34](https://github.com/AresValley/Artemis/pull/34))

 ## [3.2.2] - 2022-07-29
 ### Fixed
@@ -20,7 +98,6 @@ The first release is [3.0.0] because this is actually the third major version (c
  

 ## [3.2.0] - 2019-12-14
-
 ### Added
 - The default font can be changed ([#14](https://github.com/AresValley/Artemis/pull/14)).
 - Move `Themes` into `Settings`.
@@ -58,9 +135,16 @@ First release.


 <!-- Links definitions -->
-[Unreleased]: https://github.com/AresValley/Artemis/compare/v3.2.1...HEAD
+[Unreleased]: https://github.com/AresValley/Artemis/compare/v4.1.0...HEAD
+[4.1.0]: https://github.com/AresValley/Artemis/compare/v4.0.5...v4.1.0
+[4.0.5]: https://github.com/AresValley/Artemis/compare/v4.0.3...v4.0.5
+[4.0.3]: https://github.com/AresValley/Artemis/compare/v4.0.1...v4.0.3
+[4.0.1]: https://github.com/AresValley/Artemis/compare/v3.2.4...v4.0.1
+[3.2.4]: https://github.com/AresValley/Artemis/compare/v3.2.1...v3.2.4
+[3.2.3]: https://github.com/AresValley/Artemis/compare/v3.2.2...v3.2.3
+[3.2.2]: https://github.com/AresValley/Artemis/compare/v3.2.1...v3.2.2
 [3.2.1]: https://github.com/AresValley/Artemis/compare/v3.2.0...v3.2.1
 [3.2.0]: https://github.com/AresValley/Artemis/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/AresValley/Artemis/compare/v3.0.1...v3.1.0
 [3.0.1]: https://github.com/AresValley/Artemis/compare/v3.0.0...v3.0.1
-[3.0.0]: https://github.com/AresValley/Artemis/releases/tag/v3.0.0
+[3.0.0]: https://github.com/AresValley/Artemis/releases/tag/v3.0.0
--- a/README.md
+++ b/README.md
@@ -1,160 +1,31 @@
-<img src="documentation/ArtemisLogoSmall.png" align="right" />
+<div align="center">
+    <img src="docs/assets/logo_large_black.svg" alt="Logo" width="400">
+</div>

-# ARTEMIS 3 ![LICENSE](https://img.shields.io/github/license/AresValley/Artemis.svg?style=flat-square) ![ISSUE](https://img.shields.io/github/issues/AresValley/Artemis.svg?style=flat-square) ![LANGUAGE](https://img.shields.io/github/languages/top/AresValley/Artemis.svg?style=flat-square)
+<div align="center">

-*Radio Signals Recognition Manual*
+![GitHub Release](https://img.shields.io/github/v/release/aresvalley/artemis)
+![GitHub Release](https://img.shields.io/github/v/release/AresValley/Artemis-DB?label=DB%20version)
+![GitHub repo file or directory count (in path)](https://img.shields.io/github/directory-file-count/aresvalley/artemis-db/static?type=dir&label=DB%20signals)

-## ARTEMIS. In a nutshell.
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/aresvalley/artemis/windows.yml?logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIiB0ZXh0LXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIiBpbWFnZS1yZW5kZXJpbmc9Im9wdGltaXplUXVhbGl0eSIgZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIHZpZXdCb3g9IjAgMCA1MTIgNTEyLjAyNiI+PHBhdGggZmlsbD0iI2ZmZiIgZmlsbC1ydWxlPSJub256ZXJvIiBkPSJNMjY5LjMxMiA1MTIuMDI1SDUxMlYyNjkuMzM3SDI2OS4zMTJ2MjQyLjY4OHpNMCA1MTIuMDI1aDI0Mi42ODhWMjY5LjMzN0gwdjI0Mi42ODh6bTI2OS4zMTItMjY5LjMzN0g1MTJWMEgyNjkuMzEydjI0Mi42ODh6TTAgMjQyLjY4OGgyNDIuNjg4VjBIMHYyNDIuNjg4eiIvPjwvc3ZnPg==)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/aresvalley/artemis/linux.yml?logo=linux&logoColor=white)
+![Static Badge](https://img.shields.io/badge/build-soon%E2%84%A2-yellow?logo=apple)
+![Static Badge](https://img.shields.io/badge/build-soon%E2%84%A2-yellow?logo=raspberrypi)

-In short, ARTEMIS is a signals hunter software and a useful aid for radio listeners! The analysis of real-time spectra (from your SDR, for instance) is made simple: you can take advantage using one of the largest RF signal database (with over 370 records). Compare several signals properties (such as frequency, bandwidth, modulation, etc.) and verify what you are searching for through a waterfall/audio sample. A collection of filters allows you to narrow your search, making the identification of unknown signals, odd buzzes or weird noises way easier.
+</div>

-## Table of contents
+**Artemis** is a software designed to assist **radio frequency (RF) signal identification and storage**. It simplifies real-time spectrum analysis by leveraging one of the most extensive and community-driven databases, containing over **500 recognized signals**. This comprehensive software solution allows users to collect RF signals with specific parameters such as frequency, bandwidth, modulation, etc. Users can also store spectrum waterfalls, audio samples, and all types of documents for future reference. Artemis provides a robust platform to manage a wide range of RF data with precision and ease.

-  - [Run the software](#Run-the-software)
-    - [Run from binary](#Run-from-binary)
-    - [Run from source code](#Run-from-source-code)
-    - [Compile from source code](#Compile-from-source-code)
-  - [Database](#database)
-    - [Syntax](#syntax)
-    - [Multiple Items fields (Location, Modulation)](#multiple-items-fields-location-modulation)
-  - [Themes](#themes)
-  - [License](#license)
-  - [Thanks](#thanks)
+<div align="center">
+    <img src="docs/assets/artemis_preview.webp">
+</div>

-## Run the software
+## Documentation
+To learn more about Artemis go to the [complete documentation](https://AresValley.github.io/Artemis).

-Artemis 3 is entirely written in Python, so if you already have Python 3.7.0+ installed in your system, you can directly run the main script. Otherwise you can download a binary executable (see below).
-
-### Run from binary
-**If you don't know what you want or you are not sure where to look, this is for you.** 
-
-Basically, this is the easiest, smooth, and clean way to run Artemis 3. A Python installation is not required.
-For more information, follow [the main page of Artemis 3](https://aresvalley.com/artemis/) (detailed documentation at the end of the main page).
-
-**Requirements:**
- Windows 7/8/8.1/10
- Linux: Ubuntu 18.04+, Mint 19+, Fedora 28+ and many other. **You need at least version 2.27 of the GLIBC system library** ([details](https://github.com/AresValley/Artemis/tree/master/spec_files))
- macOS
-
-### Run from source code
-Run the software from the source code with the Python interpreter is the simplest and natural way to run Artemis 3.
-
-**Requirements:**
- Python (ver. 3.7.0+)
- Python libraries (in `requirements/requirements.txt`)
-
-1. Download and install Python (ver. 3.7.0+) from the official [website](https://www.python.org/downloads/). Be sure to select the flag `Add Python 3.x to PATH` during the first part of the installation.
-
-2. Install the necessary Python libraries with PIP. Open a console in Artemis/requirements folder and type:
-   
-```
-pip install -r  requirements.txt --user
-```
-
-3. After that launch the software in the Artemis folder with:
-   
-```
-python3 artemis.py
-```
-
-### Compile from source code
-If you want to compile Artemis yourself from the source code follow the instructions in the [spec_files/README](spec_files/README.md) file.
-
-## Database
-
-The database (db.csv) is directly extracted from sigidwiki.com with a DB parser and reworked to a standard format defined as follow. Artemis DB is a human-readable csv file where the delimiter is the character `*` (Asterisk, Unicode: U+002A). The new entry (separation between signals) is the End Of Line (EOL) escape sequence `\n`. Every signal is directly connected to spectra and audio sample stored in **Spectra** and **Audio** folders, respectively. Every signal is composed of 12 columns:
-
-| Column | Description | Unit of Measurement | Multiple Items | Type|
-| :-: | :-: | :-: | :-: | :-: |
-| 1 | Signal name | - | - | string |
-| 2 | Freq. Lower Limit | Hz | - | integer |
-| 3 | Freq. Upper Limit | Hz  | - | integer |
-| 4 | Mode | - | - | string |
-| 5 | Band. Lower Limit | Hz | - | integer |
-| 6 | Band. Upper Limit | Hz | - | integer |
-| 7 | Location | - | ✔ | string |
-| 8 | sigidwiki URL | - | - | string |
-| 9 | Description | - | - | string |
-| 10 | Modulation | - | ✔ | string |
-| 11 | ID Code | - | - | integer |
-| 12 | Auto-correlation function | ms | ✔ | string |
-
-### Syntax
-
-1. **Signal Name**: The name of the signal. A simple string that describes in short the analyzed signal. Special characters are allowed (except the main delimiter `*`).
-2. **Frequency (Lower Limit)**: The frequency lower bound expressed in Hertz.
-3. **Frequency (Upper Limit)**: The same as above but this express the frequency upper bound of the received signal.
-   
-   * In the case of a single frequency transmitter/service the **Freq. Lower Limit** and the **Freq. Upper Limit** must be coincident (same value)
-   * Transmission with different protocols must be added in two or more distinct entry. **DO NOT USE** the same signal page to add different transmission protocols (with different frequencies, bandwidth, modes,...). For example, NOAA-19 satellite transimit images and data with two different protocols:
-     
-     *  APT (Analog): 137.1000 MHz - 137.3125 MHz
-     *  HRPT (Digital): 1698 MHz - 1707 MHz
-   
-      Add two separate entry (APT and HRPT) with the correct Lower and Upper bound frequency. **DO NOT ADD** a single signal entry with a Freq. Lower Bound of 137.100 MHz and the Upper Bound of 1707 MHz.
-
-4. **Mode**: This field reports the way how a signals has been decoded during the reception.
-5. **Bandwidth (Lower Limit)**: As reported above for frequency (points 2 and 3). Also here the value is reported in Hz.
-6. **Bandwidth (Upper Limit)**: As reported above for frequency (points 2 and 3).
-7. **Location**: This is the location where the signal is distributed/received. Avoid the usage of the precise location of the TX station or very small town (very rare). It's a good habit to use nations/continents or special location (worldwide). 
-8. **sigidiwki URL**: The sigidwiki URL of the selected signal. This is a direct connection to the online database where further details of the signal are collected.
-9.  **Description**: The short description is used to explain the purpose of the signal and some other useful details.
-10. **Modulation**: The modulation is the way how the information have been encoded into the main signal (carrier). Several modification of the properties (Amplitude, Frequecy, ...) are possible and a tx station could transmit with different modulations.
-11. **ID Code**: The category code, known as ID Code, is a sequence of 0/1 and its main purpose is to assign the signal to their families/categories. It's formed by 17 digits:
-
-    |1|2|3|4|5|6|7|8|9|10|
-    |:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
-    | Military | Radar | Active | Inactive | HAM | Commercial | Aviation | Marine | Analogue | Digital|
-
-    |11|12|13|14|15|16|17|
-    |:-:|:-:|:-:|:-:|:-:|:-:|:-:|
-    | Trunked | Utility | Sat | Navigation | Interfering | Number Stations | Time Signal |
-
-12. **Auto-correlation funtion (ACF)**: The ACF is an awesome discriminator when the signal is composed of redundant pattern that continouosly repeats. Unfortunately, for this reason, ACF is not always available. The time value is reported in **ms** and, in some cases, could have multiple values for a single signal. An extended description with an example signal analysis is available here: https://aresvalley.com/documentation/
-
-
-```
-... ID Code * ACF1 Description - ACF1 Value (in ms) ; ACF2 Description - ACF2 Value (in ms) ; ...
-```
-
-**Example 1 (D-STAR):**
-
-```
-... ID Code * Superframe - 420 ; Frame - 20
-```
-**Example 2 (EDACS):**
-
-```
-... ID Code * edacs48 - 60 ; edacs96 - 30
-```
-
-**Special case:** variable ACFs are allowed and a brief explanation can be reported instead of ACF Value. A nice example is the * [SSTV](https://www.sigidwiki.com/wiki/Slow-Scan_Television_(SSTV) "SSTV") transmission where the ACF is directly related to the number of lines per minute.
-
-### Multiple Items fields (Location, Modulation)
-The necessity to manage a multiple Location/Modulation search pushed us to implement a fictitious 'secondary delimiter' chosen to be the `;` character. For instance:
-
-```
-... Band. Upper Limit * Location 1 ; Location 2 ; ... * sigidwiki URL ...
-```
-or
-```
-... Description * Modulation 1 ; Modulation 2 ; ... * ID Code ...
-```
-
-## Themes
-The only folder with the pre-built package is the `themes` one. In this way the themes are fully customizable and you can add your own. New themes (in the `themes` folder) will appear automatically in the main menu and the last used theme will be saved as the favorite one (a restart of Artemis will use the last used theme).
-
-Some of the available themes were adapted from https://github.com/GTRONICK/QSS.
-
-## License
-This program (ARTEMIS 3, 2014-2020) 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 3 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, see: www.gnu.org/licenses
-
-## Thanks
-* **Marco Dalla Tiezza** - *Artemis I-II developer, DB parsing, Website*
+## Contributors
+* **Marco Dalla Tiezza** - *Artemis I-II-IV developer, DB parsing, Website*
 * [**Alessandro Ceccato**](https://github.com/alessandro90 "GitHub profile") - *Artemis III lead developer*
 * **Paolo Romani (IZ1MLL)** - *Lead β Tester, RF specialist*
 * **Carl Colena** - *Sigidwiki admin, β Tester, Signals expert*
@@ -162,3 +33,6 @@ You should have received a copy of the GNU General Public License along with thi
 * [**Eric Wiessner (KI7POL)**](https://github.com/WheezyE "GitHub profile") - *ARM port (Raspberry Pi3B+ and Pi4B)*
 * [**Pierpaolo Pravatto**](https://github.com/ppravatto "GitHub profile") - *Wiki page, β Tester*
 * [**Francesco Capostagno**](https://github.com/fcapostagno "GitHub profile"), **Luca**, **Pietro** - *β Tester*
+
+## License
+Artemis is licensed under the [**GPL-3**](https://github.com/AresValley/Artemis/blob/master/LICENSE) license. 
--- a/app.py
+++ b/app.py
@@ -0,0 +1,28 @@
+import sys
+
+from PySide6.QtCore import QCoreApplication
+from PySide6.QtGui import QGuiApplication, QIcon
+
+from artemis.utils.constants import Constants
+from artemis.utils.ui_utils import set_ui
+from artemis.ui.artemis import UIArtemis
+
+
+def main():
+    set_ui()
+
+    QCoreApplication.setOrganizationName(Constants.ORGANIZATION_NAME)
+    QCoreApplication.setOrganizationDomain(Constants.ORGANIZATION_DOMAIN)
+    QCoreApplication.setApplicationName(Constants.APPLICATION_NAME)
+
+    app = QGuiApplication(sys.argv)
+
+    icon_file_path = (':/images/artemis_icon.ico')
+    app.setWindowIcon(QIcon(icon_file_path))
+
+    UIArtemis()
+    sys.exit(app.exec())
+
+
+if __name__ == '__main__':
+    main()
--- a/artemis-workspace.code-workspace
+++ b/artemis-workspace.code-workspace
@@ -1,7 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-	]
-}
--- a/artemis.qmlproject
+++ b/artemis.qmlproject
@@ -0,0 +1,50 @@
+import QmlProject
+
+Project {
+
+    QmlFiles {
+        directory: "ui"
+    }
+
+    QmlFiles {
+        directory: "ui/components"
+    }
+
+    ImageFiles {
+        directory: "images"
+    }
+
+    Files {
+        directory: "config"
+        filter: "*.conf"
+        files: ["qtquickcontrols2.conf"]
+    }
+
+    Environment {
+        QT_QUICK_CONTROLS_CONF: "qtquickcontrols2.conf"
+        QT_AUTO_SCREEN_SCALE_FACTOR: "1"
+        QML_COMPAT_RESOLVE_URLS_ON_ASSIGNMENT: "1"
+        QT_LOGGING_RULES: "qt.qml.connections=false"
+        QT_ENABLE_HIGHDPI_SCALING: "0"
+        /* Useful for debugging
+       QSG_VISUALIZE=batches
+       QSG_VISUALIZE=clip
+       QSG_VISUALIZE=changes
+       QSG_VISUALIZE=overdraw
+       */
+    }
+
+    qt6Project: true
+
+    qdsVersion: "4.5"
+
+    quickVersion: "6.7"
+
+    /* If any modules the project imports require widgets (e.g. QtCharts), widgetApp must be true */
+    widgetApp: true
+
+    multilanguageSupport: true
+    supportedLanguages: ["en"]
+    primaryLanguage: "en"
+
+}
--- a/artemis.qrc
+++ b/artemis.qrc
@@ -0,0 +1,54 @@
+<RCC>
+    <qresource prefix="/">
+        <file>images/artemis_icon.ico</file>
+        <file>images/artemis_icon.svg</file>
+
+        <file>images/icons/dialog_error.svg</file>
+        <file>images/icons/dialog_info.svg</file>
+        <file>images/icons/dialog_quest.svg</file>
+        <file>images/icons/dialog_warn.svg</file>
+
+        <file>images/icons/player_pause.svg</file>
+        <file>images/icons/player_play.svg</file>
+        <file>images/icons/player_stop.svg</file>
+        <file>images/icons/player_loop.svg</file>
+        <file>images/icons/save.svg</file>
+        <file>images/icons/delete.svg</file>
+        <file>images/icons/add.svg</file>
+        <file>images/icons/rename.svg</file>
+        <file>images/icons/load.svg</file>
+        <file>images/icons/open.svg</file>
+        <file>images/icons/browser.svg</file>
+        <file>images/icons/documents.svg</file>
+        <file>images/icons/abort.svg</file>
+        <file>images/icons/settings.svg</file>
+        <file>images/spectrum_not_available.svg</file>
+        <file>images/artemis_not_available.svg</file>
+
+        <file>ui/Artemis.qml</file>
+        <file>ui/DbManager.qml</file>
+        <file>ui/DialogMessage.qml</file>
+        <file>ui/Downloader.qml</file>
+        <file>ui/Preferences.qml</file>
+        <file>ui/SpaceWeather.qml</file>
+        <file>ui/DocumentsManager.qml</file>
+        <file>ui/SignalEditor.qml</file>
+        <file>ui/CategoryEditor.qml</file>
+
+        <file>ui/FilterPage.qml</file>
+        <file>ui/SignalPage.qml</file>
+        <file>ui/SpaceWeatherCurrentPage.qml</file>
+        <file>ui/SpaceWeatherForecastPage.qml</file>
+        <file>ui/SpaceWeatherDRAPPage.qml</file>
+        <file>ui/SpaceWeatherAuroraPage.qml</file>
+        <file>ui/SpaceWeatherSSA.qml</file>
+        <file>ui/SpaceWeatherSunImagers.qml</file>
+
+        <file>ui/About.qml</file>
+
+        <file>ui/components/KIndexLight.qml</file>
+        <file>ui/components/AIndexLight.qml</file>
+        <file>ui/components/AudioPlayer.qml</file>
+        <file>ui/components/BandBar.qml</file>
+    </qresource>
+</RCC>
--- a/artemis/resources.py
+++ b/artemis/resources.py
--- a/artemis/ui/artemis.py
+++ b/artemis/ui/artemis.py
@@ -0,0 +1,376 @@
+import uuid
+
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Slot, Signal
+
+from artemis.utils.constants import Constants, Messages
+from artemis.utils.sys_utils import open_directory, make_tar, unpack_tar
+from artemis.utils.sql_utils import ArtemisDatabase, ArtemisSignal
+from artemis.utils.update_utils import UpdateManager
+from artemis.utils.generic_utils import generate_filter_query
+from artemis.utils.path_utils import normalize_dialog_path
+from artemis.utils.path_utils import DATA_DIR
+from artemis.utils.config_utils import CONFIGURE_QT
+
+from artemis.ui.preferences import UIPreferences
+from artemis.ui.dbmanager import UIdbmanager
+from artemis.ui.signaleditor import UIsignaleditor
+from artemis.ui.downloader import UIDownloader
+from artemis.ui.spaceweather import UIspaceweather
+from artemis.ui.documentsmanager import UIdocumentsmanager
+from artemis.ui.categoryeditor import UIcategoryeditor
+
+import artemis.resources
+
+
+class UIArtemis(QObject):
+    # Python > QML Signals
+    close_ui = Signal()
+    populate_sig_list = Signal(list)
+    populate_sig_details = Signal(list)
+    populate_filter_modulation = Signal(list)
+    
+    clear_list = Signal()
+    clear_signal_page = Signal()
+    clear_filter_page = Signal()
+    lock_audio_player = Signal()
+    lock_menu = Signal(bool)
+
+    show_dialog_popup = Signal(str, str, str)
+    show_dialog_download_db = Signal(str, str, str)
+    show_dialog_update_artemis = Signal(str, str, str, bool)
+    update_info_bar = Signal(str, str)
+
+
+    def __init__(self):
+        super().__init__()
+
+        # Main UI initialization
+        self._engine = QQmlApplicationEngine()
+        self._engine.rootContext().setContextProperty('APPLICATION_VERSION', Constants.APPLICATION_VERSION)
+        self._engine.rootContext().setContextProperty('PYTHON_VERSION', Constants.PYTHON_VERSION)
+        self._engine.rootContext().setContextProperty('QT_VERSION', Constants.QT_VERSION)
+        self._engine.load('qrc:/ui/Artemis.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._window_filter = self._window.findChild(QObject, "filterPageObj")
+        self._window_signal = self._window.findChild(QObject, "signalPageObj")
+
+        self.loaded_db = None
+
+        self._connect()
+
+        # Creating istances for other windows
+        self.preferences = UIPreferences(self)
+        self.dbmanager = UIdbmanager(self)
+        self.spaceweather = UIspaceweather(self)
+        self.docmanager = UIdocumentsmanager(self)
+        self.sigeditor = UIsignaleditor(self)
+        self.cateditor = UIcategoryeditor(self)
+        self.downloader = UIDownloader(self)
+
+        self.update_manager = UpdateManager(self)
+
+        self.autoload_db()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.showDBmanager.connect(self.show_dbmanager_ui)
+        self._window.loadSignal.connect(self.load_sig)
+        self._window.showPref.connect(self.show_pref_ui)
+        self._window.openSigEditor.connect(self.open_sig_editor)
+        self._window.checkForUpdate.connect(self.check_for_update)
+        self._window.updateDb.connect(self.update_db)
+        self._window.updateArtemis.connect(self.update_artemis)
+        self._window.showSpaceWeather.connect(self.show_space_weather_ui)
+        self._window.openDbDirectory.connect(self.open_db_directory)
+        self._window.showCatManager.connect(self.open_cat_manager)
+        
+        self._window.newDb.connect(self.new_db)
+        self._window.exportDb.connect(self.export_db)
+        self._window.importDb.connect(self.import_db)
+
+        self._window_filter.applyFilter.connect(self.apply_filter)
+        self._window_filter.sendBottomAlert.connect(self.bottom_info_bar)
+
+        self._window_signal.openDocManager.connect(self.show_documentsmanager_ui)
+        self._window_signal.openSigEditor.connect(self.open_sig_editor)
+        self._window_signal.deleteCatTag.connect(self.delete_cat_tag)
+        self._window_signal.addCatTag.connect(self.add_cat_tag)
+
+        # Python > QML connections
+        self.close_ui.connect(self._window.close)
+        self.populate_sig_list.connect(self._window.populateList)
+        self.clear_list.connect(self._window.clearList)
+        self.update_info_bar.connect(self._window.bottomInfoBar)
+        self.show_dialog_popup.connect(self._window.openGeneralDialog)
+        self.show_dialog_download_db.connect(self._window.openDialogDownloadDb)
+        self.show_dialog_update_artemis.connect(self._window.openDialogUpdateArtemis)
+        self.lock_menu.connect(self._window.lockMenu)
+
+        self.populate_sig_details.connect(self._window_signal.populateSignalParam)
+        self.lock_audio_player.connect(self._window_signal.lockPlayer)
+        self.clear_signal_page.connect(self._window_signal.resetAll)
+        
+        self.clear_filter_page.connect(self._window_filter.resetAll)
+        self.populate_filter_modulation.connect(self._window_filter.loadLists)
+
+
+    def load_db(self, db_dir_name):
+        """ Load the DB and populate the signals list
+
+        Args:
+            db_dir_name (str): folder name in the data folder
+        """
+        # Loading DB
+        self.loaded_db = ArtemisDatabase(db_dir_name)
+        self.loaded_db.load()
+        # Clearing UI
+        self.lock_menu.emit(False)
+        self.clear_signal_page.emit()
+        self.clear_filter_page.emit()
+        # Populating UI
+        self.load_filter_lists()
+        self.populate_sig_list.emit(self.loaded_db.all_signals)
+        # Updating status bar
+        total_signals = len(self.loaded_db.all_signals)
+        self.bottom_info_bar("Database loaded with {} signals".format(total_signals), "info")
+
+
+    @Slot(int)
+    def load_sig(self, sig_id):
+        """ Load the selected signal and populate the SignalPage
+
+        Args:
+            sig_id (int): SIG_ID of the signal to be loaded 
+        """
+        self.loaded_sig = ArtemisSignal(self.loaded_db)
+        self.loaded_sig.load(sig_id)
+        sig_dic = self.loaded_sig.generate_dic()
+
+        self.populate_sig_details.emit([sig_dic])
+
+
+    def load_filter_lists(self):
+        """ Populates the 3 listviews in the FilterPage
+        """
+        self.populate_filter_modulation.emit([{
+            'modulation': self.loaded_db.all_modulation,
+            'location': self.loaded_db.all_location,
+            'category': self.loaded_db.all_category_labels
+        }])
+
+
+    @Slot(dict)
+    def apply_filter(self, filter_status):
+        """ Update the signal list according to the selected filters in the FilterPage.
+
+        Args:
+            filter_status (dic): dictionary containing the active filters with all
+            the details to generate a search query
+        """
+        filter_status = filter_status.toVariant()
+        if self.loaded_db is not None:
+            if filter_status != {}:
+                filter_query = generate_filter_query(filter_status)
+                self.loaded_db.select_by_filter(filter_query)
+                
+                self.clear_signal_page.emit()
+                self.populate_sig_list.emit(self.loaded_db.all_signals)
+
+                total_signals = len(self.loaded_db.all_signals)
+                self.bottom_info_bar("FILTERS ACTIVE: {} signals found".format(total_signals), "warning")
+            else:
+                self.load_db(self.loaded_db.db_dir_name)
+
+
+    def show_pref_ui(self):
+        """ Load the preference windows
+        """
+        self.preferences.load_preferences_ui()
+
+
+    def show_dbmanager_ui(self):
+        """ Load the DB manager windows
+        """
+        self.dbmanager.load_dbmanager_ui()
+
+
+    @Slot(str, list, bool)
+    def open_sig_editor(self, type, sig_param, is_new):
+        """ Open the signal editor windows
+            Called when the user want to add, edit or delete the signal or its parametes.
+        """
+        self.sigeditor.load_signaleditor_ui(type, sig_param, is_new)
+
+
+    def show_space_weather_ui(self):
+        """ Open the space weather windows
+        """
+        self.spaceweather.load_spaceweather_ui()
+
+
+    def show_documentsmanager_ui(self):
+        """ Open the documents manager windows
+        """
+        self.docmanager.load_documentsmanager_ui()
+
+
+    def check_for_update(self):
+        """ User manual check for updates updates
+        """
+        self.update_manager.check_updates(True)
+
+
+    def dialog_download_db(self, message_type, title, message):
+        """ Dialog popup for DB download confirmation
+        """
+        self.show_dialog_download_db.emit(message_type, title, message)
+
+
+    def dialog_update_artemis(self, message_type, title, message, auto=False):
+        """ Dialog popup for Artemis download confirmation
+        """
+        self.show_dialog_update_artemis.emit(message_type, title, message, auto)
+
+
+    @Slot()
+    def update_db(self):
+        """ Start the download of the sigID DB
+        """
+        self.update_manager.download_db()
+
+
+    @Slot()
+    def update_artemis(self):
+        """ Start the download of Artemis
+        """
+        self.update_manager.download_artemis()
+
+
+    def open_db_directory(self):
+        """ Open the local folder of the loaded DB
+        """
+        open_directory(self.loaded_db.db_dir)
+
+
+    @Slot(str)
+    def new_db(self, name):
+        """ Create a new local DB
+
+        Args:
+            name (str): name of the new DB, hardcoded in sql info table
+        """
+        try:
+            new_db = ArtemisDatabase(str(uuid.uuid4()))
+            new_db.create(name)
+            self.load_db(new_db.db_dir_name)
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_INFO,
+                Messages.GENERIC_SUCCESS,
+                Messages.DB_CREATION_SUCCESS_MSG
+            )
+        except Exception as e:
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_ERROR,
+                Messages.GENERIC_ERROR,
+                Messages.GENERIC_ERROR_MSG.format(e)
+            )
+
+
+    @Slot(str)
+    def export_db(self, save_path):
+        """ Export the load DB in a tar file. Does not use compression
+
+        Args:
+            save_path (str): destination path of the generated .tar file
+        """
+        try:
+            dest_path = normalize_dialog_path(save_path)
+            make_tar(dest_path, self.loaded_db.db_dir)
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_INFO,
+                Messages.GENERIC_SUCCESS,
+                Messages.EXPORTING_SUCCESS_MSG
+            )
+        except Exception as e:
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_ERROR,
+                Messages.GENERIC_ERROR,
+                Messages.GENERIC_ERROR_MSG.format(e)
+            )
+
+
+    @Slot(str)
+    def import_db(self, tar_path):
+        """ Import a new DB in the Artemis data folder
+
+        Args:
+            tar_path (str): Path of the archive to be imported
+        """
+        try:
+            origin_path = normalize_dialog_path(tar_path)
+            save_path = DATA_DIR / str(uuid.uuid4())
+            unpack_tar(origin_path, save_path)
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_INFO,
+                Messages.GENERIC_SUCCESS,
+                Messages.IMPORTING_SUCCESS_MSG
+            )
+        except Exception as e:
+            self.dialog_popup(
+                Messages.DIALOG_TYPE_ERROR,
+                Messages.GENERIC_ERROR,
+                Messages.GENERIC_ERROR_MSG.format(e)
+            )
+
+
+    @Slot(int)
+    def add_cat_tag(self, clb_id):
+        self.loaded_sig.insert_category(clb_id)
+        self.load_db(self.loaded_db.db_dir_name)
+
+
+    @Slot(int)
+    def delete_cat_tag(self, cat_id):
+        self.loaded_sig.delete_category(cat_id)
+        self.load_db(self.loaded_db.db_dir_name)
+
+
+    def open_cat_manager(self):
+        """ Open the category manager windows
+        """
+        self.cateditor.load_cateditor_ui()
+
+
+    def autoload_db(self):
+        """ This will autoload the latest local sigID DB, if present
+            according to the user settings
+        """
+        sig_id_db = self.dbmanager.get_latest_local_sigid_db()
+        autoload = CONFIGURE_QT.value("Database", "autoload", 0)
+        if sig_id_db is not None and int(autoload):
+            self.load_db(sig_id_db.db_dir_name)
+
+
+    def dialog_popup(self, message_type, title, message):
+        """ Opens a general dialog popup
+
+        Args:
+            message_type (str): 'info', 'question', 'warn', 'error'
+            title (str): header of the dialoog
+            message (sstr): description inside the dialog
+        """
+        self.show_dialog_popup.emit(message_type, title, message)
+
+
+    @Slot(str, str)
+    def bottom_info_bar(self, message, message_type):
+        """ Manage the footer info bar
+
+        Args:
+            message (str): text to be shown in the info bar
+            message_type (str): 'info', 'warning'
+        """
+        self.update_info_bar.emit(message, message_type)
--- a/artemis/ui/categoryeditor.py
+++ b/artemis/ui/categoryeditor.py
@@ -0,0 +1,67 @@
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Signal, Slot
+
+from artemis.utils.path_utils import *
+from artemis.utils.generic_utils import *
+
+
+class UIcategoryeditor(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    load = Signal(list)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/CategoryEditor.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.saveParam.connect(self.save)
+        self._window.deleteParam.connect(self.delete)
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.load.connect(self._window.loadList)
+
+
+    def load_cateditor_ui(self):
+        """ Load the list with existing category tags and show the UI
+        """
+        all_cat = self._parent.loaded_db.all_category_labels
+        self.load.emit(all_cat)
+        self.show_ui.emit()
+
+
+    @Slot(list, bool)
+    def save(self, data, is_new):
+        """ Save new category tag or update the existing ones.
+        """
+        data = data.toVariant()
+
+        if is_new:
+            self._parent.loaded_db.insert_category_label(data[0])
+        else:
+            self._parent.loaded_db.update_category_label(data[1], data[0])
+
+        self._parent.load_db(self._parent.loaded_db.db_dir_name)
+        self.load_cateditor_ui()
+
+
+    @Slot(int)
+    def delete(self, clb_id):
+        """ Delete a database category tag.
+            All the entries in the documents table are automatically beign deleted due to 
+            foreign-key cascade propagation
+        """
+        self._parent.loaded_db.delete_category_label(clb_id)
+        self._parent.load_db(self._parent.loaded_db.db_dir_name)
+        self.load_cateditor_ui()
--- a/artemis/ui/dbmanager.py
+++ b/artemis/ui/dbmanager.py
@@ -0,0 +1,131 @@
+import os
+
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Signal, Slot
+
+from artemis.utils.path_utils import DATA_DIR
+from artemis.utils.generic_utils import *
+from artemis.utils.sql_utils import ArtemisDatabase
+from artemis.utils.sys_utils import delete_dir
+
+
+class UIdbmanager(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    close_ui = Signal()
+    populate_db_list = Signal(list)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/DbManager.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.loadDB.connect(self.load_db)
+        self._window.deleteDB.connect(self.delete_db)
+        self._window.renameDB.connect(self.rename_db)
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.close_ui.connect(self._window.close)
+        self.populate_db_list.connect(self._window.loadList)
+
+
+    def load_dbmanager_ui(self):
+        self.load_local_db_list()
+        self.show_ui.emit()
+
+
+    def load_local_db_list(self):
+        """ Scan for all the valid DBs in the data folder and show them on the list
+        """
+        db_param = []
+        valid_db_list = self.scan_db_dir()
+
+        for db in valid_db_list:
+            db_param.append(
+                {
+                    'name': db.name,
+                    'version': db.version,
+                    'date': parse_date(db.date),
+                    'db_dir_name': db.db_dir_name,
+                    'documents_n': db.stats['documents'],
+                    'signals_n': db.stats['signals'],
+                    'images_n': db.stats['images'],
+                    'audio_n': db.stats['audio']
+                }
+            )
+
+        self.populate_db_list.emit(db_param)
+
+
+    def load_db(self, db_dir_name):
+        """ Load the selected DB (from the DB Manager list) in the main artemis window
+        """
+        self._parent.load_db(db_dir_name)
+        self.close_ui.emit()
+
+
+    @Slot(str)
+    def delete_db(self, db_dir_name):
+        """ Delete the DB folder.
+            Clear the main UI if the database to be deleted is the selected one 
+        """
+        if self._parent.loaded_db is not None:
+            if self._parent.loaded_db.db_dir_name == db_dir_name:
+                self._parent.lock_menu.emit(True)
+                self._parent.clear_list.emit()
+                self._parent.clear_signal_page.emit()
+        delete_dir(DATA_DIR / db_dir_name)
+        self.load_local_db_list()
+
+
+    @Slot(str, str)
+    def rename_db(self, db_dir_name, new_name):
+        """ Rename db in the data folder
+        """
+        database = ArtemisDatabase(db_dir_name)
+        database.rename(new_name)
+        self.load_local_db_list()
+
+
+    def scan_db_dir(self):
+        """ Scans the data directory for valid databases and
+            return a dictionary containing only the valid ones.
+            Returns a list of objects (dbs)
+        """
+        valid_db_list = []
+        db_dirs = next(os.walk(DATA_DIR))[1]
+
+        for db_dir_name in db_dirs:
+            try:
+                database = ArtemisDatabase(db_dir_name)
+                database.load()
+                valid_db_list.append(database)
+            except:
+                continue
+
+        return valid_db_list
+
+
+    def get_latest_local_sigid_db(self):
+        """ Return the newest valid local sigID database.
+            Returns None if no valid sigID database is found.
+        """
+        valid_dbs = self._parent.dbmanager.scan_db_dir()
+        sig_id_dbs = [db for db in valid_dbs if db.editable == -1]
+
+        if len(sig_id_dbs) != 0:
+            sig_id_latest = max(sig_id_dbs, key=lambda x: x.version)
+            return sig_id_latest
+        else:
+            return None
--- a/artemis/ui/documentsmanager.py
+++ b/artemis/ui/documentsmanager.py
@@ -0,0 +1,128 @@
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Signal, Slot
+
+from artemis.utils.path_utils import *
+from artemis.utils.generic_utils import *
+from artemis.utils.sys_utils import *
+
+
+class UIdocumentsmanager(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    close_ui = Signal()
+    populate_documents_list = Signal(list)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/DocumentsManager.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.saveNewDoc.connect(self.save_new_doc)
+        self._window.deleteDoc.connect(self.delete_doc)
+        self._window.updateDoc.connect(self.update_doc)
+        self._window.openDoc.connect(self.open_doc)
+
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.close_ui.connect(self._window.close)
+        self.populate_documents_list.connect(self._window.loadList)
+
+
+    def load_documentsmanager_ui(self):
+        self.load_documents_list()
+        self.show_ui.emit()
+
+
+    def load_documents_list(self):
+        """ Load the documents of the selected signal and populate the documents list
+        """
+        self._parent.loaded_sig.select_documents()
+        all_documents = self._parent.loaded_sig.documents
+        
+        keys = (
+            'doc_id',
+            'extension',
+            'name',
+            'description',
+            'type',
+            'preview'
+        )
+        
+        doc_lst = [dict(zip(keys, values)) for values in all_documents]
+        self.populate_documents_list.emit(doc_lst)
+
+
+    @Slot(list)
+    def save_new_doc(self, doc_lst):
+        """ Save the new document (identified by the DOC_ID = -1) and reload the document list.
+            doc_param contains all the details of the new documents. 
+        """
+        doc_param = doc_lst.toVariant()
+        file_extension = os.path.splitext(doc_param[0])[1][1:]
+
+        doc_id = self._parent.loaded_sig.insert_document([
+            -1,
+            file_extension,
+            doc_param[1],
+            doc_param[2],
+            doc_param[3],
+            0
+        ])
+
+        local_file_name = '{}.{}'.format(str(doc_id), file_extension)
+        origin_path = normalize_dialog_path(doc_param[0])
+        copy_file(origin_path, self._parent.loaded_db.media_dir / local_file_name)
+        self.load_documents_list()
+
+
+    @Slot(list)
+    def update_doc(self, doc_lst):
+        """ Update the details of the existent document
+        """
+        doc_list = doc_lst.toVariant()
+        for doc in doc_list:
+            self._parent.loaded_sig.update_documents(doc[0], doc[1], doc[2], doc[3], doc[4])
+        self.load_documents_list()
+
+
+    @Slot(str, str)
+    def open_doc(self, doc_id, extension):
+        """ Open the selected document with the proper system application (if any)
+        """
+        try:
+            open_file(self._parent.loaded_db.media_dir / '{}.{}'.format(doc_id, extension))
+        except Exception as e:
+            self.close_ui.emit()
+            self._parent.dialog_popup(
+                Messages.DIALOG_TYPE_ERROR,
+                Messages.GENERIC_ERROR,
+                str(e)
+            )
+
+
+    @Slot(str, str, str, bool)
+    def delete_doc(self, doc_id, doc_extension, doc_type, doc_preview):
+        """ Delete the selected document
+        """
+        doc_file_name = '{}.{}'.format(doc_id, doc_extension)
+        doc_file_path = self._parent.loaded_db.media_dir / doc_file_name
+        
+        self._parent.loaded_sig.delete_document(doc_id)
+        
+        if doc_preview:
+            if doc_type == 'Audio':
+                self._parent.lock_audio_player.emit()
+
+        delete_file(doc_file_path)
+        self.load_documents_list()
--- a/artemis/ui/downloader.py
+++ b/artemis/ui/downloader.py
@@ -0,0 +1,167 @@
+import requests
+
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Slot, Signal, QUrl, QSaveFile, QDir, QIODevice
+from PySide6.QtNetwork import QNetworkReply, QNetworkRequest, QNetworkAccessManager
+
+from artemis.utils.constants import Messages
+
+
+class UIDownloader(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    close_ui = Signal()
+    update_progress_bar = Signal(int, int)
+    set_indeterminate_bar = Signal()
+    update_status = Signal(str)
+    finished = Signal()
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/Downloader.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self.file_url = None
+        self.file_size = None
+        self.dest_file = None
+        self.file = None
+        self.manager = None
+        self.reply = None
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.onAbort.connect(self.on_abort)
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.close_ui.connect(self._window.close)
+        self.update_progress_bar.connect(self._window.updateProgressBar)
+        self.set_indeterminate_bar.connect(self._window.setIndeterminateBar)
+        self.update_status.connect(self._window.updateStatus)
+
+
+    def on_start(self, url, save_path):
+        """ Start the download process using the specified URL
+
+        Args:
+            url (str): url from where download the file
+            save_path (str): path where to save the downloaded file
+        """
+        self._clear_ui()
+        self.show_ui.emit()
+
+        self.file_url = QUrl(url)
+        self.file_size = self._get_filesize(url)
+        dest_path = QDir(save_path)
+        self.dest_file = dest_path.filePath(self.file_url.fileName())
+        self.file = QSaveFile(self.dest_file)
+
+        if self.file.open(QIODevice.WriteOnly):
+            # Start a GET HTTP request
+            self.manager = QNetworkAccessManager(self)
+            self.reply = self.manager.get(QNetworkRequest(self.file_url))
+            self.reply.downloadProgress.connect(self.on_progress)
+            self.reply.finished.connect(self.on_finished)
+            self.reply.readyRead.connect(self.on_ready_read)
+            self.reply.errorOccurred.connect(self.on_error)
+        else:
+            self.close_ui.emit()
+            self.show_popup_error(self.file.errorString())
+
+
+    @Slot()
+    def on_abort(self):
+        """ Stop the download when user presses the abort button
+        """
+        if self.reply:
+            self.reply.abort()
+
+        if self.file:
+            self.file.cancelWriting()
+
+
+    @Slot()
+    def on_ready_read(self):
+        """ Write available bytes to the file
+        """
+        if self.reply:
+            if self.reply.error() == QNetworkReply.NoError:
+                self.file.write(self.reply.readAll())
+
+
+    @Slot()
+    def on_finished(self):
+        """ Finalize the download process and, if no errors
+            occurs, emits the finished signal usefull for
+            a callback
+        """
+        if self.reply:
+            self.reply.deleteLater()
+
+        if self.file:
+            self.file.commit()
+        
+        if self.reply.error() == QNetworkReply.NoError:
+            self.finished.emit()
+
+        self.close_ui.emit()
+
+
+    @Slot(int, int)
+    def on_progress(self, bytesReceived: int):
+        """ Update progress bar and status label
+        """
+        if self.file_size is not None:
+            self.update_status.emit("{:.1f} Mb / {:.1f} Mb".format(bytesReceived/10**6, self.file_size/10**6))
+            self.update_progress_bar.emit(bytesReceived, self.file_size)
+        else:
+            self.update_status.emit("{:.1f} Mb".format(bytesReceived/10**6))
+
+
+    @Slot(QNetworkReply.NetworkError)
+    def on_error(self, code: QNetworkReply.NetworkError):
+        """ Show a message if an error happen during download
+        """
+        if self.reply:
+            self.close_ui.emit()
+            self.show_popup_error(
+                self.reply.errorString()
+            )
+
+
+    def _get_filesize(self, url):
+        """ Get the file size by sending a HEAD request to the URL.
+            If the Content-Length in HTTP headers is missing, returns None
+            and set the progress_bar as 'indeterminate' like a 'busy indicator'
+
+        Args:
+            url (str): URL to check the file size
+        """
+        try:
+            response = requests.get(url, stream=True)
+            size = int(response.headers.get('content-length'))
+            return size
+        except:
+            self.set_indeterminate_bar.emit()
+            return None
+
+
+    def _clear_ui(self):
+        self.update_progress_bar.emit(0, 0)
+        self.update_status.emit('')
+
+
+    def show_popup_error(self, error_msg):
+        self._parent.dialog_popup(
+            Messages.DIALOG_TYPE_ERROR,
+            Messages.GENERIC_ERROR,
+            Messages.GENERIC_ERROR_MSG.format(error_msg)
+        )
--- a/artemis/ui/preferences.py
+++ b/artemis/ui/preferences.py
@@ -0,0 +1,67 @@
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Slot, Signal
+
+from artemis.utils.config_utils import *
+
+
+class UIPreferences(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    load_material_accent = Signal(str)
+    load_material_theme = Signal(str)
+    load_autoload = Signal(int)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/Preferences.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.saveMaterialAccent.connect(self.save_material_accent)
+        self._window.saveMaterialTheme.connect(self.save_material_theme)
+        self._window.saveAutoload.connect(self.save_autoload)
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.load_material_accent.connect(self._window.loadMaterialAccent)
+        self.load_material_theme.connect(self._window.loadMaterialTheme)
+        self.load_autoload.connect(self._window.loadAutoload)
+
+
+    def load_preferences_ui(self):
+        """ Loading all the initial preferences from the conf file to the UI
+        """
+        self.load_material_accent.emit(CONFIGURE_QT.value("Material", "Accent", "Green"))
+        self.load_material_theme.emit(CONFIGURE_QT.value("Material", "Theme", "System"))
+        self.load_autoload.emit(int(CONFIGURE_QT.value("Database", "autoload", 0)))
+        self.show_ui.emit()
+
+
+    @Slot(str)
+    def save_material_accent(self, material_accent):
+        """ Saving material accent setting
+        """
+        CONFIGURE_QT.set("Material", "Accent", material_accent)
+
+
+    @Slot(str)
+    def save_material_theme(self, material_theme):
+        """ Saving material theme setting
+        """
+        CONFIGURE_QT.set("Material", "Theme", material_theme)
+
+
+    @Slot(int)
+    def save_autoload(self, autoload):
+        """ Saving autoload setting
+        """
+        CONFIGURE_QT.set("Database", "autoload", str(autoload))
--- a/artemis/ui/signaleditor.py
+++ b/artemis/ui/signaleditor.py
@@ -0,0 +1,126 @@
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Signal, Slot
+
+from artemis.utils.path_utils import *
+from artemis.utils.generic_utils import *
+from artemis.utils.sql_utils import ArtemisSignal
+from artemis.utils.sys_utils import delete_file
+
+
+class UIsignaleditor(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    load = Signal(str, list, bool)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/SignalEditor.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+        self._window.saveParam.connect(self.save)
+        self._window.deleteParam.connect(self.delete)
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.load.connect(self._window.load)
+
+
+    def load_signaleditor_ui(self, param_type, sig_param, is_new):
+        """ Load all the details of the selected signal
+
+        Args:
+            param_type (str): Signal, Frequency, Bandwidth, Modulation, Mode,
+                ACF, Location
+            sig_param (list): a list formed as [id, value, description]
+            is_new (bool): If true, the windows open in an empty state ready to 
+                be compiled by the user. If false, the windows will open all the 
+                current parameter for the loaded signal, for editing or deleting purposes.
+        """
+        if param_type == 'Signal' and not is_new:
+            sig_param = [
+                self._parent.loaded_sig.sig_id,
+                self._parent.loaded_sig.name,
+                self._parent.loaded_sig.description
+            ]
+        self.load.emit(param_type, sig_param, is_new)
+        self.show_ui.emit()
+
+
+    @Slot(str, list, bool)
+    def save(self, param_type, data, is_new):
+        """ Save new signal parameters or update the existing ones.
+        """
+        data = data.toVariant()
+
+        if is_new:
+            if param_type == 'Signal':
+                self._parent.loaded_sig = ArtemisSignal(self._parent.loaded_db)
+                self._parent.loaded_sig.insert_signal(data[1], data[2])
+            elif param_type == 'Frequency':
+                self._parent.loaded_sig.insert_frequency(int(data[1]), data[2])
+            elif param_type == 'Bandwidth':
+                self._parent.loaded_sig.insert_bandwidth(int(data[1]), data[2])
+            elif param_type == 'Modulation':
+                self._parent.loaded_sig.insert_modulation(data[1], data[2])        
+            elif param_type == 'Mode':
+                self._parent.loaded_sig.insert_mode(data[1], data[2])
+            elif param_type == 'ACF':
+                self._parent.loaded_sig.insert_acf(data[1], data[2])
+            elif param_type == 'Location':
+                self._parent.loaded_sig.insert_location(data[1], data[2])
+        else:
+            if param_type == 'Signal':
+                self._parent.loaded_sig.update_signal(data[0], data[1], data[2])
+            elif param_type == 'Frequency':
+                self._parent.loaded_sig.update_frequency(data[0], int(data[1]), data[2])
+            elif param_type == 'Bandwidth':
+                self._parent.loaded_sig.update_bandwidth(data[0], int(data[1]), data[2])
+            elif param_type == 'Modulation':
+                self._parent.loaded_sig.update_modulation(data[0], data[1], data[2])        
+            elif param_type == 'Mode':
+                self._parent.loaded_sig.update_mode(data[0], data[1], data[2])
+            elif param_type == 'ACF':
+                self._parent.loaded_sig.update_acf(data[0], data[1], data[2])
+            elif param_type == 'Location':
+                self._parent.loaded_sig.update_location(data[0], data[1], data[2])
+
+        self._parent.load_db(self._parent.loaded_db.db_dir_name)
+
+
+    @Slot(str, int)
+    def delete(self, param_type, id):
+        """ Delete a signal parameter or the signal itself (with all the parameters and documents).
+            All the entries in the documents table are automatically beign deleted due to 
+            foreign-key cascade propagation
+        """
+        if param_type == 'Signal':
+            self._parent.loaded_sig.delete_signal()
+            self._parent.lock_audio_player.emit()
+            for doc in self._parent.loaded_sig.documents:
+                doc_file_name = '{}.{}'.format(str(doc[0]), doc[1])
+                doc_file_path = self._parent.loaded_db.media_dir / doc_file_name
+                delete_file(doc_file_path)
+        elif param_type == 'Frequency':
+            self._parent.loaded_sig.delete_frequency(id)
+        elif param_type == 'Bandwidth':
+            self._parent.loaded_sig.delete_bandwidth(id)
+        elif param_type == 'Modulation':
+            self._parent.loaded_sig.delete_modulation(id)        
+        elif param_type == 'Mode':
+            self._parent.loaded_sig.delete_mode(id)
+        elif param_type == 'ACF':
+            self._parent.loaded_sig.delete_acf(id)
+        elif param_type == 'Location':
+            self._parent.loaded_sig.delete_location(id)
+
+        self._parent.load_db(self._parent.loaded_db.db_dir_name)
--- a/artemis/ui/spaceweather.py
+++ b/artemis/ui/spaceweather.py
@@ -0,0 +1,81 @@
+from PySide6.QtQml import QQmlApplicationEngine
+from PySide6.QtCore import QObject, Signal
+
+from artemis.utils.path_utils import *
+from artemis.utils.generic_utils import *
+
+from artemis.utils.constants import Constants
+
+
+class UIspaceweather(QObject):
+    # Python > QML Signals
+    show_ui = Signal()
+    load_poseidon_report = Signal(dict)
+    load_poseidon_forecast_report = Signal(dict)
+    load_poseidon_drap_report = Signal(dict)
+    load_poseidon_SSA_report = Signal(dict)
+    load_poseidon_sun_images_report = Signal(dict)
+    load_aurora_report = Signal()
+    update_bottom_bar = Signal(str)
+
+
+    def __init__(self, parent):
+        super().__init__()
+
+        self._parent = parent
+
+        self._engine = QQmlApplicationEngine()
+        self._engine.load('qrc:/ui/SpaceWeather.qml')
+        self._window = self._engine.rootObjects()[0]
+
+        self._window_current = self._window.findChild(QObject, "spaceWeatherCurrentObj")
+        self._window_forecast = self._window.findChild(QObject, "spaceWeatherForecastObj")
+        self._window_drap = self._window.findChild(QObject, "spaceWeatherDRAPObj")
+        self._window_aurora = self._window.findChild(QObject, "spaceWeatherAuroraObj")
+        self._window_SSA = self._window.findChild(QObject, "spaceWeatherSSA")
+        self._window_sun_images = self._window.findChild(QObject, "spaceWeatherSunImagers")
+
+        self._connect()
+
+
+    def _connect(self):
+        # QML > Python connections
+
+        # Python > QML connections
+        self.show_ui.connect(self._window.show)
+        self.update_bottom_bar.connect(self._window.updateBottomBar)
+        self.load_poseidon_report.connect(self._window_current.loadReport)
+        self.load_poseidon_forecast_report.connect(self._window_forecast.loadForecastReport)
+        self.load_poseidon_drap_report.connect(self._window_drap.loadDrapReport)
+        self.load_poseidon_SSA_report.connect(self._window_SSA.loadDrapReport)
+        self.load_poseidon_sun_images_report.connect(self._window_sun_images.loadDrapReport)
+        self.load_aurora_report.connect(self._window_aurora.loadAuroraReport)
+
+
+    def load_spaceweather_ui(self):
+        """ Before opening the windows, poseidon report (data.json) is read online
+        """
+        self.download_poseidon_report()
+    
+
+    def download_poseidon_report(self):
+        update_manager = self._parent.update_manager
+        poseidon_data = update_manager.fetch_remote_json(
+            Constants.POSEIDON_REPORT_URL,
+            True
+        )
+        if poseidon_data:
+            self.load_poseidon_report.emit(poseidon_data)
+            self.load_poseidon_forecast_report.emit(poseidon_data)
+            self.load_poseidon_drap_report.emit(poseidon_data)
+            self.load_poseidon_sun_images_report.emit(poseidon_data)
+            self.load_poseidon_SSA_report.emit(poseidon_data)
+            self.load_aurora_report.emit()
+
+            self.update_bottom_bar.emit(
+                'Loaded Poseidon report issued on {} at {} UTC'.format(
+                    poseidon_data['JSON_INFO']['utc_date'],
+                    poseidon_data['JSON_INFO']['utc_time']
+                )
+            )
+            self.show_ui.emit()
--- a/artemis/utils/config_utils.py
+++ b/artemis/utils/config_utils.py
@@ -0,0 +1,75 @@
+from configparser import ConfigParser
+
+from artemis.utils.path_utils import PREFERENCES_DIR, BASE_DIR
+from artemis.utils.sys_utils import copy_file
+
+
+class Config(ConfigParser):
+    """ Custom configuration class derived from ConfigParser.
+        Used to get value, set, save and remove any configuration from the conf file
+    """
+
+    def __init__(self, config_file_path, space_around_delimiters=False):
+        super().__init__()
+        self._config_file_path = config_file_path
+        self.read(self._config_file_path)
+        self._space_around_delimiters = space_around_delimiters
+
+    def value(self, section, option, default_value):
+        value = super().get(section, option, fallback=default_value)
+        return value
+
+    def set(self, section, option, value=None):
+        if not self.has_section(section):
+            self.add_section(section)
+        super().set(section, option, value)
+        self.save()
+
+    def remove(self, section, option):
+        super().remove_option(section, option)
+        self.save()
+
+    def save(self):
+        with open(self._config_file_path, 'w') as f:
+            self.write(f, space_around_delimiters=self._space_around_delimiters)
+
+
+def merge_config_files(old_config_path, template_config_path):
+    """ Merge two configuration files: if the old one lacks some
+        sections or options from a comparison with a template,
+        this function will add what is missing to the old conf file
+    """
+    old_config = ConfigParser()
+    old_config.read(old_config_path)
+    
+    new_config = ConfigParser()
+    new_config.read(template_config_path)
+    
+    for section in new_config.sections():
+        if not old_config.has_section(section):
+            old_config.add_section(section)
+        for option in new_config.options(section):
+            if not old_config.has_option(section, option):
+                old_config.set(section, option, new_config.get(section, option))
+    
+    with open(old_config_path, 'w') as f:
+        old_config.write(f)
+
+
+def check_conf_file():
+    """ Check the integrity of the used conf file.
+        If it is not present it will add a copy to the PREF_DIR
+        and if it is different in structure (different section/options)
+        it will merge the conf file with the new template one
+    """
+    active_conf = (PREFERENCES_DIR / 'qtquickcontrols2.conf').resolve()
+    template_conf = (BASE_DIR / 'config' / 'qtquickcontrols2.conf').resolve()
+
+    if not active_conf.exists():
+        copy_file(template_conf, active_conf)
+    else:
+        merge_config_files(active_conf, template_conf)
+
+
+check_conf_file()
+CONFIGURE_QT = Config((PREFERENCES_DIR / 'qtquickcontrols2.conf').resolve().as_posix())
--- a/artemis/utils/constants.py
+++ b/artemis/utils/constants.py
@@ -0,0 +1,493 @@
+import locale
+import sys
+
+from PySide6.QtCore import qVersion
+
+
+class Constants():
+    """ Container class for several constants of the software """
+
+    APPLICATION_NAME            = 'Artemis'
+    ORGANIZATION_NAME           = 'AresValley'
+    ORGANIZATION_DOMAIN         = 'aresvalley.com'
+    APPLICATION_VERSION         = '4.1.0'
+
+    SQL_NAME                    = 'data.sqlite'
+
+    LATEST_VERSION_URL          = 'https://raw.githubusercontent.com/AresValley/Artemis/master/config/release-info.json'
+    POSEIDON_REPORT_URL         = 'https://www.aresvalley.com/poseidon_engine/data.json'
+
+    DEFAULT_ENCODING            = 'utf-8'
+    SYSTEM_LANGUAGE             = 'en_US' # locale.getdefaultlocale()[0]
+    PYTHON_VERSION              = '.'.join(str(v) for v in sys.version_info[:3])
+    QT_VERSION                  = qVersion()
+
+
+class Messages:
+    """ Container class for messages to be displayed """
+    # Type
+    DIALOG_TYPE_INFO            = 'info'
+    DIALOG_TYPE_QUEST           = 'question'
+    DIALOG_TYPE_WARN            = 'warn'
+    DIALOG_TYPE_ERROR           = 'error'
+
+    # Titles
+    GENERIC_SUCCESS             = "Success!"
+    GENERIC_ERROR               = "Something went wrong!"
+    NO_DB_DETECTED              = "No SigID database detected..."
+    NO_CONNECTION               = "Connection Error!"
+    UP_TO_DATE                  = "You're up to date!"
+    DB_NEW_VER                  = "New SigID DB version available!"
+    ART_NEW_VER                 = "New Artemis version available!"
+    DB_CORRUPTED                = "Database Corruption Detected"
+
+    # Messages
+    DB_CREATION_SUCCESS_MSG     = "The new database has been created succesfully."
+    GENERIC_ERROR_MSG           = "An error occurred during the process. Details: {}"
+    IMPORTING_SUCCESS_MSG       = "Database importing has been succesfully completed!"
+    EXPORTING_SUCCESS_MSG       = "Database exporting has been succesfully completed!"
+    FILE_NOT_FOUND_ERR_MSG      = "The file you are trying to access cannot be located. This may be because the file has been moved or deleted."
+    NO_DB_DETECTED_MSG          = "Do you want to download it now?"
+    NO_CONNECTION_MSG           = "Unable to check for updates. It appears that there is a problem with your internet connection. Please check your network settings and try again later. {}"
+    UP_TO_DATE_MSG              = "The latest version of Artemis and SigID wiki is installed on your computer."
+    DB_NEW_VER_MSG              = "A new version of the database ({}) is available for download. Download now?"
+    ART_NEW_VER_MANUAL_MSG      = "A new version of Artemis ({}) is available for download. Check GitHub page now?"
+    ART_NEW_VER_AUTO_MSG        = "A new version of Artemis ({}) is available for download. Update Artemis now?"
+    DB_CORRUPTED_MSG            = "Downloaded data corrupted or invalid. Please retry."
+    DB_DOWNLOAD_SUCCESS_MSG     = "The database has been successfully downloaded and is now being loaded."
+
+
+class Query():
+    """ Container class for all the sqlite queries """
+    
+############################## SELECT
+
+    SELECT_ALL_SIGNALS = "SELECT SIG_ID, NAME, DESCRIPTION FROM signals ORDER BY NAME ASC"
+    
+    SELECT_ALL_MODULATION = "SELECT DISTINCT VALUE FROM modulation ORDER BY VALUE ASC"
+    
+    SELECT_ALL_LOCATION = "SELECT DISTINCT VALUE FROM location ORDER BY VALUE ASC"
+    
+    SELECT_SIG_ID = "SELECT SIG_ID, NAME, DESCRIPTION FROM signals WHERE SIG_ID IN ({}) ORDER BY NAME ASC"
+
+    SELECT_ALL_CAT_LABELS = "SELECT CLB_ID, VALUE FROM category_label ORDER BY VALUE ASC"
+    
+    SELECT_INFO = """
+        SELECT
+            NAME,
+            DATE,
+            VERSION,
+            EDITABLE
+        FROM info
+    """
+
+    SELECT_SIGNAL = """
+        SELECT
+            NAME,
+            DESCRIPTION,
+            URL
+        FROM signals WHERE SIG_ID = ?
+    """
+    
+    SELECT_CATEGORY = """
+        SELECT
+            category.CAT_ID,
+            category_label.VALUE
+        FROM category
+        INNER JOIN category_label ON category.CLB_ID = category_label.CLB_ID
+        WHERE SIG_ID = ?
+    """
+
+    SELECT_DOCUMENTS = """
+        SELECT
+            DOC_ID,
+            EXTENSION,
+            NAME,
+            DESCRIPTION,
+            TYPE,
+            PREVIEW 
+        FROM documents WHERE SIG_ID = ?
+        ORDER BY TYPE ASC
+    """
+
+    SELECT_FREQUENCY = """
+        SELECT
+            FREQ_ID,
+            VALUE,
+            DESCRIPTION
+        FROM frequency WHERE SIG_ID = ?
+    """
+
+    SELECT_BANDWIDTH = """
+        SELECT
+            BAND_ID,
+            VALUE,
+            DESCRIPTION
+        FROM bandwidth WHERE SIG_ID = ?
+    """
+
+    SELECT_MODULATION = """
+        SELECT
+            MDL_ID,
+            VALUE,
+            DESCRIPTION
+        FROM modulation WHERE SIG_ID = ?
+    """
+
+    SELECT_MODE= """
+        SELECT
+            MOD_ID,
+            VALUE,
+            DESCRIPTION
+        FROM mode WHERE SIG_ID = ?
+    """
+
+    SELECT_LOCATION = """
+        SELECT
+            LOC_ID,
+            VALUE,
+            DESCRIPTION
+        FROM location WHERE SIG_ID = ?
+    """
+
+    SELECT_ACF = """
+        SELECT
+            ACF_ID,
+            VALUE,
+            DESCRIPTION
+        FROM acf WHERE SIG_ID = ?
+    """
+
+    SELECT_STAT_DOCS = """
+        SELECT COUNT(*)
+            FROM documents
+    """
+    
+    SELECT_STAT_IMAGES = """
+        SELECT COUNT(*)
+            FROM documents
+        WHERE type IS 'Image'
+    """
+
+    SELECT_STAT_AUDIO = """
+        SELECT COUNT(*)
+            FROM documents
+        WHERE type IS 'Audio'
+    """    
+
+############################## CREATE
+
+    CREATE_SIGNALS = """
+        CREATE TABLE signals (
+            SIG_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            NAME        TEXT,
+            DESCRIPTION TEXT,
+            URL         TEXT
+        )
+    """
+
+    CREATE_CATEGORY = """
+        CREATE TABLE category (
+            CAT_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER,
+            CLB_ID      INTEGER,
+            FOREIGN KEY (SIG_ID) REFERENCES signals (SIG_ID) ON DELETE CASCADE ON UPDATE CASCADE,
+            FOREIGN KEY (CLB_ID) REFERENCES category_label (CLB_ID) ON DELETE CASCADE ON UPDATE CASCADE
+        )
+    """
+
+    CREATE_CATEGORY_LABELS = """
+        CREATE TABLE category_label (
+            CLB_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            VALUE       TEXT
+        )   
+    """
+
+    CREATE_DOCUMENTS = """
+        CREATE TABLE documents (
+            DOC_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER REFERENCES signals (SIG_ID) ON DELETE CASCADE,
+            EXTENSION   TEXT,
+            NAME        TEXT,
+            DESCRIPTION TEXT,
+            TYPE        TEXT,
+            PREVIEW     INTEGER
+        )
+    """
+    
+    CREATE_FREQUENCY = """
+        CREATE TABLE frequency (
+            FREQ_ID     INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER REFERENCES signals (SIG_ID) ON DELETE CASCADE,
+            VALUE       INTEGER,
+            DESCRIPTION TEXT
+        )    
+    """
+    
+    CREATE_BANDWIDTH = """
+        CREATE TABLE bandwidth (
+            BAND_ID     INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER REFERENCES signals (SIG_ID) ON DELETE CASCADE,
+            VALUE       INTEGER,
+            DESCRIPTION TEXT
+        )    
+    """    
+
+    CREATE_MODULATION = """
+        CREATE TABLE modulation (
+            MDL_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER REFERENCES signals (SIG_ID) ON DELETE CASCADE,
+            VALUE       TEXT,
+            DESCRIPTION TEXT
+        )
+    """
+
+    CREATE_MODE = """
+        CREATE TABLE mode (
+            MOD_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER,
+            VALUE       TEXT,
+            DESCRIPTION TEXT,
+            FOREIGN KEY (SIG_ID) REFERENCES signals (SIG_ID) ON DELETE CASCADE ON UPDATE CASCADE
+        )
+    """
+
+    CREATE_LOCATION = """
+        CREATE TABLE location (
+            LOC_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER,
+            VALUE       TEXT,
+            DESCRIPTION TEXT,
+            FOREIGN KEY (SIG_ID) REFERENCES signals (SIG_ID) ON DELETE CASCADE ON UPDATE CASCADE
+        )
+    """
+
+    CREATE_ACF = """
+        CREATE TABLE acf (
+            ACF_ID      INTEGER PRIMARY KEY AUTOINCREMENT,
+            SIG_ID      INTEGER REFERENCES signals (SIG_ID) ON DELETE CASCADE,
+            VALUE       FLOAT,
+            DESCRIPTION TEXT
+        )    
+    """     
+
+    CREATE_INFO = """
+        CREATE TABLE info (
+            NAME        TEXT,
+            DATE        TEXT,
+            VERSION     INTEGER,
+            EDITABLE    INTEGER
+        )   
+    """
+
+    CREATE_VIEW_FREQ = """
+        CREATE VIEW FREQ_RANGE AS
+            SELECT SIG_ID,
+                MIN(VALUE) AS MIN_VALUE,
+                MAX(VALUE) AS MAX_VALUE
+            FROM frequency
+            GROUP BY SIG_ID
+    """        
+
+    CREATE_VIEW_BAND = """
+        CREATE VIEW BAND_RANGE AS
+            SELECT SIG_ID,
+                MIN(VALUE) AS MIN_VALUE,
+                MAX(VALUE) AS MAX_VALUE
+            FROM bandwidth
+            GROUP BY SIG_ID 
+    """
+
+############################## INSERT
+
+    INSERT_SIGNAL = """
+        INSERT INTO signals (
+            NAME,
+            DESCRIPTION
+        ) VALUES (?,?)
+    """
+
+    INSERT_CATEGORY = """
+        INSERT INTO category (
+            SIG_ID,
+            CLB_ID
+        ) VALUES (?,?)
+    """
+
+    INSERT_CATEGORY_LABEL = """
+        INSERT INTO category_label (
+            VALUE
+        ) VALUES (?)
+    """
+
+    INSERT_INFO = """
+        INSERT INTO info (
+            NAME,
+            DATE,
+            VERSION,
+            EDITABLE
+        ) VALUES (?,?,?,?)
+    """
+
+    INSERT_DOCUMENTS = """
+        INSERT INTO documents (
+            SIG_ID,
+            EXTENSION,
+            NAME,
+            DESCRIPTION,
+            TYPE,
+            PREVIEW 
+        ) VALUES (?,?,?,?,?,?)
+    """
+
+    INSERT_FREQUENCY = """
+        INSERT INTO frequency (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+    INSERT_BANDWIDTH = """
+        INSERT INTO bandwidth (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+    INSERT_MODULATION = """
+        INSERT INTO modulation (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+    INSERT_MODE = """
+        INSERT INTO mode (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+    INSERT_LOCATION = """
+        INSERT INTO location (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+    INSERT_ACF = """
+        INSERT INTO acf (
+            SIG_ID,
+            VALUE,
+            DESCRIPTION
+        ) VALUES (?,?,?)
+    """
+
+############################## UPDATE
+
+    RENAME_DB = "UPDATE info SET NAME = ?"
+
+    UPDATE_SIGNAL = """
+        UPDATE signals SET
+            NAME = ?,
+            DESCRIPTION = ?
+        WHERE SIG_ID = ?
+    """
+
+    UPDATE_CATEGORY_LABEL = """
+        UPDATE category_label SET
+            VALUE = ?
+        WHERE CLB_ID = ?
+    """
+
+    UPDATE_FREQUENCY = """
+        UPDATE frequency SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE FREQ_ID = ?
+    """
+
+    UPDATE_BANDWIDTH = """
+        UPDATE bandwidth SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE BAND_ID = ?
+    """
+
+    UPDATE_ACF = """
+        UPDATE acf SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE ACF_ID = ?
+    """
+
+    UPDATE_MODE = """
+        UPDATE mode SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE MOD_ID = ?
+    """
+
+    UPDATE_LOCATION = """
+        UPDATE location SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE LOC_ID = ?
+    """
+
+    UPDATE_MODULATION = """
+        UPDATE modulation SET
+            VALUE = ?,
+            DESCRIPTION = ?
+        WHERE MDL_ID = ?
+    """
+
+    UPDATE_DOCUMENTS = """
+        UPDATE documents SET
+            NAME = ?,
+            DESCRIPTION = ?,
+            TYPE = ?,
+            PREVIEW = ?
+        WHERE DOC_ID = ?
+    """
+
+############################## DELETE
+    
+    DELETE_SIGNAL = "DELETE FROM signals WHERE SIG_ID = ?"
+
+    DELETE_DOCUMENT = "DELETE FROM documents WHERE DOC_ID = ?"
+
+    DELETE_FREQUENCY = "DELETE FROM frequency WHERE FREQ_ID = ?"
+
+    DELETE_BANDWIDTH = "DELETE FROM bandwidth WHERE BAND_ID = ?"
+
+    DELETE_MODULATION = "DELETE FROM modulation WHERE MDL_ID = ?"
+    
+    DELETE_MODE = "DELETE FROM mode WHERE MOD_ID = ?"
+    
+    DELETE_LOCATION = "DELETE FROM location WHERE LOC_ID = ?"
+
+    DELETE_ACF = "DELETE FROM acf WHERE ACF_ID = ?"
+
+    DELETE_CATEGORY = "DELETE FROM category WHERE CAT_ID = ?"
+
+    DELETE_CATEGORY_LABEL = "DELETE FROM category_label WHERE CLB_ID = ?"
+
+############################## FILTER QUERY
+
+    FILTER_FREQ = "SELECT SIG_ID FROM FREQ_RANGE WHERE ({} >= MIN_VALUE) AND ({} <= MAX_VALUE)"
+
+    FILTER_BAND = "SELECT SIG_ID FROM BAND_RANGE WHERE ({} >= MIN_VALUE) AND ({} <= MAX_VALUE)"
+
+    FILTER_ACF = "SELECT SIG_ID FROM acf WHERE ({} >= VALUE) AND ({} <= VALUE)"
+
+    FILTER_MODULATION = "SELECT SIG_ID FROM modulation WHERE VALUE IN ({})"
+
+    FILTER_LOCATION = "SELECT SIG_ID FROM location WHERE VALUE IN ({})"
+
+    FILTER_CATEGORY = "SELECT SIG_ID FROM category WHERE CLB_ID IN ({})"
--- a/artemis/utils/generic_utils.py
+++ b/artemis/utils/generic_utils.py
@@ -0,0 +1,93 @@
+from datetime import datetime
+
+from artemis.utils.constants import Query
+
+
+def format_frequency(freq_hz):
+    """ Return frequency in a human-readable format
+
+    Args:
+        freq_hz (int): frequency in Hz
+    """
+    scale = _change_unit_freq(freq_hz)
+    formatted_freq = f'{freq_hz / scale[0]} {scale[1]}'
+    return formatted_freq
+
+
+def _change_unit_freq(freq_hz):
+    """ Return a scale factor and unit based on the number of digits in the frequency
+
+    Args:
+        freq_hz (int): frequency in Hz
+    """
+    digits = len(str(freq_hz))
+
+    if digits < 4:
+        return 1, 'Hz'
+    elif digits < 7:
+        return 10**3, 'kHz'
+    elif digits < 10:
+        return 10**6, 'MHz'
+    else:
+        return 10**9, 'GHz'
+
+
+def generate_filter_query(filer_status):
+    """ Returns the sql query according to the selected filter parameters 
+
+    Args:
+        filer_status (dic): dictionary containing a summary of the active
+        filtering options with the related parametes.
+    """
+    query = []
+
+    for key, val in filer_status.items():
+
+        if key == 'frequency':
+            query.append(Query.FILTER_FREQ.format(
+                val['upper_band'],
+                val['lower_band']
+            ))
+
+        elif key == 'bandwidth':
+            query.append(Query.FILTER_BAND.format(
+                val['upper_band'],
+                val['lower_band']
+            ))
+
+        elif key == 'acf':
+            query.append(Query.FILTER_ACF.format(
+                val['upper_band'],
+                val['lower_band']
+            ))
+
+        elif key == 'modulation':
+            query.append(Query.FILTER_MODULATION.format(
+                ', '.join(f"'{mod}'" for mod in val)
+            ))
+
+        elif key == 'location':
+            query.append(Query.FILTER_LOCATION.format(
+                ', '.join(f"'{loc}'" for loc in val)
+            ))
+
+        elif key == 'category':
+            query.append(Query.FILTER_CATEGORY.format(
+                ', '.join(f"{cat}" for cat in val)
+            ))
+
+    return ' INTERSECT '.join(query)
+
+
+def parse_date(date_str):
+    """ Parses a date string in "%Y-%m-%d %H:%M:%S.%f" format and returns
+    the date in "YYYY-MM-DD" format. If parsing fails, returns the original string.
+
+    Args:
+        date_str (str): The date string to parse.
+    """
+    try:
+        form_date = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S.%f")
+        return str(form_date.date())
+    except ValueError:
+        return date_str
--- a/artemis/utils/path_utils.py
+++ b/artemis/utils/path_utils.py
@@ -0,0 +1,59 @@
+import os
+from pathlib import Path
+
+from artemis.utils.constants import Constants
+from artemis.utils.sys_utils import is_windows, is_linux, is_macos
+
+
+def normalize_dialog_path(path):
+    if is_windows():
+        norm_path = path.replace('file:///', '')
+    elif is_linux() or is_macos():
+        norm_path = path.replace('file:///', '/')
+    return norm_path
+
+
+def _app_dir():
+    if is_macos():
+        app_dir_path = Path.home() / 'Library' / 'Application Support' / Constants.ORGANIZATION_NAME / Constants.APPLICATION_NAME
+    elif is_windows():
+        app_dir_path = Path.home() / 'AppData' / 'Local' / Constants.ORGANIZATION_NAME / Constants.APPLICATION_NAME
+    elif is_linux():
+        app_dir_path = Path.home() / '.local' / 'share' / Constants.ORGANIZATION_NAME / Constants.APPLICATION_NAME
+    else:
+        app_dir_path = BASE_DIR.resolve()
+
+    if not app_dir_path.exists():
+        app_dir_path.mkdir(parents=True)
+
+    return app_dir_path
+
+
+def _data_dir():
+    data_dir_path = APP_DIR / 'data'
+    if not data_dir_path.exists():
+        data_dir_path.mkdir(parents=True)
+    return data_dir_path
+
+
+def _tmp_dir():
+    if is_windows():
+        tmp_dir_path = Path.home() / 'AppData' / 'Local' / 'Temp'
+    else:
+        tmp_dir_path = Path('/tmp')
+
+    return tmp_dir_path
+
+
+def _preference_dir():
+    preference_dir_path = APP_DIR / 'config'
+    if not preference_dir_path.exists():
+        preference_dir_path.mkdir(parents=True)
+    return preference_dir_path    
+
+
+BASE_DIR = Path(os.path.dirname(__file__)) / '../..'
+APP_DIR = _app_dir()
+DATA_DIR = _data_dir()
+TMP_DIR = _tmp_dir()
+PREFERENCES_DIR = _preference_dir()
--- a/artemis/utils/sql_utils.py
+++ b/artemis/utils/sql_utils.py
@@ -0,0 +1,417 @@
+import os
+import sqlite3
+
+from PySide6.QtCore import QUrl
+from operator import itemgetter
+from datetime import datetime
+from contextlib import closing
+
+from artemis.utils.constants import Query, Constants
+from artemis.utils.generic_utils import format_frequency
+from artemis.utils.path_utils import DATA_DIR
+
+
+class Database():
+    """ General superclass for SQLite DB manipulation.
+        Foreign keys are activated (otherwise disabled by default for compatibility purposes)
+    """
+    def __init__(self, sql_path):
+        self.sql_path = sql_path
+
+    def execute(self, query, parameters=None, last_rowid=False):
+        """ Open a connection, execute the given query with optional parameters and close the connection. 
+            In the case of a SELECT query, returns the results as a fetchall().
+            If last_rowid == True, this function returns a tuple with the result of the fetchall() and
+            the latest modified row id of the current connection.
+        """
+        with closing(sqlite3.connect(self.sql_path, check_same_thread=False)) as conn:
+            conn.execute('PRAGMA foreign_keys = ON;')
+
+            curs = conn.cursor()
+
+            if parameters:
+                curs.execute(query, parameters)
+            else:
+                curs.execute(query)
+
+            conn.commit()
+
+            if last_rowid:
+                result = (curs.fetchall(), curs.lastrowid)
+            else:
+                result = curs.fetchall()
+
+        return result
+
+################################## MARK: >>> DATABASE <<<
+
+class ArtemisDatabase(Database):
+    """ General CRUD class for SQLite DB manipulation.
+        Foreign keys are activated (otherwise disabled by default for compatibility purposes) 
+    """
+
+    def __init__(self, db_dir_name):
+        self.db_dir_name = db_dir_name
+        self.db_dir = DATA_DIR / db_dir_name
+        self.sql_path = self.db_dir / Constants.SQL_NAME
+        self.media_dir = self.db_dir / 'media'
+        super().__init__(self.sql_path)
+        
+        self.name = None
+        self.date = None
+        self.version = None
+        self.editable = None
+
+        self.all_signals = None
+        self.all_modulation = None
+        self.all_location = None
+        self.all_category_labels = None
+
+        self.filtered_signals = None
+        
+        self.stats = {}
+
+
+    def load(self):
+        self._select_info()
+        self._select_all()
+        self._select_all_modulation()
+        self._select_all_location()
+        self._select_all_category_labels()
+        self._select_stats()
+
+
+    def _select_info(self):
+        """ Load the DB meta INFO from the table 'info'
+        """
+        result = self.execute(Query.SELECT_INFO)[0]
+        self.name = result[0]
+        self.date = result[1]
+        self.version = result[2]
+        self.editable = result[3]
+
+
+    def _select_all(self):
+        """ Load a list of tuple for all signals. Each tuple (representing a signal)
+            contains the SIG_ID and the NAME of the signal
+        """
+        self.all_signals = self.execute(Query.SELECT_ALL_SIGNALS)
+        keys = ('SIG_ID', 'name', 'description')
+        result = [dict(zip(keys, values)) for values in self.all_signals]
+        self.all_signals = result
+
+
+    def _select_all_modulation(self):
+        self.all_modulation = self.execute(Query.SELECT_ALL_MODULATION)
+        self.all_modulation = [{'value': item[0]} for item in self.all_modulation]
+
+
+    def _select_all_location(self):
+        self.all_location = self.execute(Query.SELECT_ALL_LOCATION)
+        self.all_location = [{'value': item[0]} for item in self.all_location]
+
+
+    def _select_all_category_labels(self):
+        self.all_category_labels = self.execute(Query.SELECT_ALL_CAT_LABELS)
+        self.all_category_labels = [{'clb_id': item[0], 'value': item[1]} for item in self.all_category_labels]
+
+
+    def _select_stats(self):
+        tot_docs = self.execute(Query.SELECT_STAT_DOCS)[0][0]
+        tot_images = self.execute(Query.SELECT_STAT_IMAGES)[0][0]
+        tot_audio = self.execute(Query.SELECT_STAT_AUDIO)[0][0]
+
+        self.stats['documents'] = tot_docs
+        self.stats['images'] = tot_images
+        self.stats['audio'] = tot_audio
+        self.stats['signals'] = len(self.all_signals)
+
+
+    def select_by_filter(self, filter_query):
+        matching_sig_ids = self.execute(filter_query)
+        sig_ids = ",".join(str(num[0]) for num in matching_sig_ids)
+
+        self.all_signals = self.execute(Query.SELECT_SIG_ID.format(sig_ids))
+        keys = ('SIG_ID', 'name', 'description')
+        result = [dict(zip(keys, values)) for values in self.all_signals]
+        self.all_signals = result
+
+
+    def create(self, name):
+        """ Create new db in the data folder.
+            The name of folder containing the new db has a unique id as name (db_dir_name).
+        """
+        meta = [name, datetime.now(), 1, 1]
+        os.makedirs(self.db_dir)
+        os.makedirs(self.media_dir)
+
+        self.execute(Query.CREATE_INFO)
+        self.execute(Query.INSERT_INFO, meta)
+        self.execute(Query.CREATE_SIGNALS)
+        self.execute(Query.CREATE_CATEGORY)
+        self.execute(Query.CREATE_CATEGORY_LABELS)
+        self.execute(Query.CREATE_FREQUENCY)
+        self.execute(Query.CREATE_BANDWIDTH)
+        self.execute(Query.CREATE_MODULATION)
+        self.execute(Query.CREATE_MODE)
+        self.execute(Query.CREATE_LOCATION)
+        self.execute(Query.CREATE_ACF)
+        self.execute(Query.CREATE_DOCUMENTS)
+
+        self.execute(Query.CREATE_VIEW_FREQ)
+        self.execute(Query.CREATE_VIEW_BAND)
+
+
+    def rename(self, name):
+        self.execute(Query.RENAME_DB, [name])
+
+
+    def insert_category_label(self, value):
+        self.execute(Query.INSERT_CATEGORY_LABEL, [value])
+
+
+    def update_category_label(self, clb_id, value):
+        self.execute(Query.UPDATE_CATEGORY_LABEL, [value, clb_id])
+
+
+    def delete_category_label(self, clb_id):
+        self.execute(Query.DELETE_CATEGORY_LABEL, [clb_id])
+
+################################## MARK: >>> SIGNAL <<<
+
+class ArtemisSignal():
+    """ Main class of the object signal
+    """
+
+    def __init__(self, loaded_db):
+        self.db = loaded_db
+
+        self.sig_id = None
+        self.name = None
+        self.description = None
+        self.url = None
+        self.category = None
+        self.frequency = None
+        self.bandwidth = None
+        self.modulation = None
+        self.mode = None
+        self.location = None
+        self.acf = None
+        
+        self.documents = None
+        self.spectrum_path = None
+        self.audio_path = None
+
+
+    def load(self, sig_id):
+        self.sig_id = sig_id
+        self._select_signals()
+        self._select_category()
+        self._select_frequency()
+        self._select_bandwidth()
+        self._select_modulation()
+        self._select_mode()
+        self._select_location()
+        self._select_acf()
+        self.select_documents()
+
+
+    def generate_dic(self):
+        dic = {
+            'name': self.name,
+            'description': self.description,
+            'url': self.url,
+            'category': self.category,
+            'frequency': self.frequency,
+            'bandwidth': self.bandwidth,
+            'modulation': self.modulation,
+            'mode': self.mode,
+            'location': self.location,
+            'acf': self.acf,
+            'spectrum_path': self.spectrum_path,
+            'audio_path': self.audio_path,
+            'all_category': self.db.all_category_labels
+        }
+        return dic
+
+
+################################## MARK: SELECT Methods
+
+
+    def _select_signals(self):
+        signal = self.db.execute(Query.SELECT_SIGNAL, [self.sig_id])[0]
+        self.name = signal[0]
+        self.description = signal[1]
+        self.url = signal[2]
+
+
+    def _select_category(self):
+        self.category = self.db.execute(Query.SELECT_CATEGORY, [self.sig_id])
+        self.category = [list(x) for x in self.category]
+
+
+    def _select_frequency(self):
+        result = self.db.execute(Query.SELECT_FREQUENCY, [self.sig_id])
+        sorted_list = sorted(result, key=itemgetter(1))
+        self.frequency = [list(x) + [format_frequency(x[1])] for x in sorted_list]
+
+
+    def _select_bandwidth(self):
+        result = self.db.execute(Query.SELECT_BANDWIDTH, [self.sig_id])
+        sorted_list = sorted(result, key=itemgetter(1))
+        self.bandwidth = [list(x) + [format_frequency(x[1])] for x in sorted_list]
+
+
+    def _select_acf(self):
+        self.acf = self.db.execute(Query.SELECT_ACF, [self.sig_id])
+        self.acf = [list(x) for x in self.acf]
+
+
+    def _select_modulation(self):
+        self.modulation = self.db.execute(Query.SELECT_MODULATION, [self.sig_id])
+        self.modulation = [list(x) for x in self.modulation]
+
+
+    def _select_mode(self):
+        self.mode = self.db.execute(Query.SELECT_MODE, [self.sig_id])
+        self.mode = [list(x) for x in self.mode]
+
+
+    def _select_location(self):
+        self.location = self.db.execute(Query.SELECT_LOCATION, [self.sig_id])
+        self.location = [list(x) for x in self.location]
+
+
+    def select_documents(self):
+        self.documents = self.db.execute(Query.SELECT_DOCUMENTS, [self.sig_id])
+
+        default_spectrum = [doc for doc in self.documents if doc[4] == 'Image' and doc[5] == 1]
+        default_audio = [doc for doc in self.documents if doc[4] == 'Audio' and doc[5] == 1]
+
+        if default_spectrum != []:
+            default_spectrum_filename = '{}.{}'.format(str(default_spectrum[0][0]), default_spectrum[0][1])
+            self.spectrum_path = self.db.media_dir / default_spectrum_filename
+            self.spectrum_path = QUrl.fromLocalFile(self.spectrum_path.resolve())
+        else:
+            self.spectrum_path = 'qrc:///images/spectrum_not_available.svg'
+
+        if default_audio != []:
+            default_audio_filename = '{}.{}'.format(str(default_audio[0][0]), default_audio[0][1])
+            self.audio_path = self.db.media_dir / default_audio_filename
+            self.audio_path = QUrl.fromLocalFile(self.audio_path.resolve())
+        else:
+            self.audio_path = ''
+
+
+################################## MARK: UPDATE Methods
+
+
+    def update_signal(self, sig_id, value, description):
+        self.db.execute(Query.UPDATE_SIGNAL, [value, description, sig_id])
+
+
+    def update_frequency(self, freq_id, value, description):
+        self.db.execute(Query.UPDATE_FREQUENCY, [value, description, freq_id])
+
+
+    def update_bandwidth(self, band_id, value, description):
+        self.db.execute(Query.UPDATE_BANDWIDTH, [value, description, band_id])
+
+
+    def update_modulation(self, modu_id, value, description):
+        self.db.execute(Query.UPDATE_MODULATION, [value, description, modu_id])
+
+
+    def update_mode(self, mode_id, value, description):
+        self.db.execute(Query.UPDATE_MODE, [value, description, mode_id])
+
+
+    def update_acf(self, acf_id, value, description):
+        self.db.execute(Query.UPDATE_ACF, [value, description, acf_id])
+
+
+    def update_location(self, loc_id, value, description):
+        self.db.execute(Query.UPDATE_LOCATION, [value, description, loc_id])
+
+
+    def update_documents(self, doc_id, name, description, type, is_preview):
+            self.db.execute(Query.UPDATE_DOCUMENTS, [name, description, type, is_preview, doc_id])
+
+
+################################## MARK: INSERT Methods
+
+
+    def insert_signal(self, value, description):
+        self.db.execute(Query.INSERT_SIGNAL, [value, description])
+
+
+    def insert_frequency(self, value, description):
+        self.db.execute(Query.INSERT_FREQUENCY, [self.sig_id, value, description])
+
+
+    def insert_bandwidth(self, value, description):
+        self.db.execute(Query.INSERT_BANDWIDTH, [self.sig_id,value, description])
+
+
+    def insert_modulation(self, value, description):
+        self.db.execute(Query.INSERT_MODULATION, [self.sig_id,value, description])
+
+
+    def insert_mode(self, value, description):
+        self.db.execute(Query.INSERT_MODE, [self.sig_id,value, description])
+
+
+    def insert_acf(self, value, description):
+        self.db.execute(Query.INSERT_ACF, [self.sig_id,value, description])
+
+
+    def insert_location(self, value, description):
+        self.db.execute(Query.INSERT_LOCATION, [self.sig_id,value, description])
+
+
+    def insert_category(self, clb_id):
+        self.db.execute(Query.INSERT_CATEGORY, [self.sig_id, clb_id])
+
+
+    def insert_document(self, doc_lst):
+        row_id = self.db.execute(Query.INSERT_DOCUMENTS, [self.sig_id] + doc_lst[1:], True)[1]
+        return row_id
+
+
+################################## MARK: DELETE Methods
+
+
+    def delete_signal(self):
+        self.db.execute(Query.DELETE_SIGNAL, [self.sig_id])
+
+
+    def delete_frequency(self, freq_id):
+        self.db.execute(Query.DELETE_FREQUENCY, [freq_id])
+
+
+    def delete_bandwidth(self, band_id):
+        self.db.execute(Query.DELETE_BANDWIDTH, [band_id])
+
+
+    def delete_modulation(self, modu_id):
+        self.db.execute(Query.DELETE_MODULATION, [modu_id])
+
+
+    def delete_mode(self, mode_id):
+        self.db.execute(Query.DELETE_MODE, [mode_id])
+
+
+    def delete_acf(self, acf_id):
+        self.db.execute(Query.DELETE_ACF, [acf_id])
+
+
+    def delete_location(self, loc_id):
+        self.db.execute(Query.DELETE_LOCATION, [loc_id])
+
+
+    def delete_document(self, doc_id):
+        self.db.execute(Query.DELETE_DOCUMENT, [doc_id])
+
+
+    def delete_category(self, cat_id):
+        self.db.execute(Query.DELETE_CATEGORY, [cat_id])
--- a/artemis/utils/sys_utils.py
+++ b/artemis/utils/sys_utils.py
@@ -0,0 +1,100 @@
+import os
+import platform
+import subprocess
+import hashlib
+
+from shutil import rmtree, copyfile, make_archive, unpack_archive
+from pathlib import Path
+
+from artemis.utils.constants import Messages
+
+
+def is_windows():
+    return platform.system() == 'Windows'
+
+def is_macos():
+    return platform.system() == 'Darwin'
+
+def is_linux():
+    return platform.system() == 'Linux'
+
+
+def open_file(file_path, timeout=3):
+    try:
+        if is_windows():
+            os.startfile(file_path)
+        elif is_macos():
+            subprocess.call(['open', file_path], timeout=timeout)
+        elif is_linux():
+            subprocess.call(['xdg-open', file_path], timeout=timeout)
+        else:
+            return
+    except FileNotFoundError:
+        raise Exception(Messages.FILE_NOT_FOUND_ERR_MSG)
+    except Exception as e:
+        raise Exception(Messages.GENERIC_ERROR_MSG.format(e))
+
+
+def open_directory(directory, timeout=3):
+    if is_windows():
+        subprocess.call(['explorer', str(Path(directory))], timeout=timeout)
+    elif is_macos():
+        subprocess.call(['open', directory], timeout=timeout)
+    elif is_linux():
+        subprocess.call(['xdg-open', directory], timeout=timeout)
+    else:
+        return
+
+
+def copy_file(src_file_path, dst_file_path):
+    copyfile(src_file_path, dst_file_path)
+
+
+def delete_dir(dir_path):
+    if os.path.exists(dir_path):
+        rmtree(dir_path)    
+
+
+def delete_file(file_path):
+    if os.path.exists(file_path):
+        os.remove(file_path) 
+
+
+def make_tar(save_path, origin_path):
+    """ Create a tar archive from a folder
+
+    Args:
+        save_path: destination path where new tar is saved
+        origin_path: directory path of the folder to be archived
+    """
+    make_archive(save_path, 'tar', origin_path.resolve().as_posix())
+
+
+def unpack_tar(tar_path, destination_path):
+    """ Unpack a tar archive in a folder
+
+    Args:
+        tar_path: path of the tar to be unpacked
+        destination_path: path where the tar is extracted
+    """
+    unpack_archive(tar_path, destination_path, 'tar')
+
+
+def match_hash(data, reference_hash):
+    """ Check whether the checksum of 'data' match the reference one.
+
+    Args:
+        data (str): Path of the file to be checked
+        reference_hash (str): Reference SHA-256 hash
+    """
+    if reference_hash is None:
+        raise ValueError("ERROR: Invalid hash code.")
+
+    code = hashlib.sha256()
+    b = bytearray(128*1024)
+    mv = memoryview(b)
+    with open(data, 'rb', buffering=0) as f:
+        while n := f.readinto(mv):
+            code.update(mv[:n])
+
+    return code.hexdigest() == reference_hash
--- a/artemis/utils/ui_utils.py
+++ b/artemis/utils/ui_utils.py
@@ -0,0 +1,23 @@
+import os
+
+from artemis.utils.sys_utils import is_windows, is_linux, is_macos
+from artemis.utils.config_utils import CONFIGURE_QT
+
+
+def set_ui():
+    os.environ['QT_QUICK_CONTROLS_STYLE'] = CONFIGURE_QT.value('Controls', 'style', 'Material')
+    os.environ['QT_QUICK_CONTROLS_MATERIAL_VARIANT'] = CONFIGURE_QT.value('Material', 'variant', 'Dense')
+    os.environ['QT_QUICK_CONTROLS_MATERIAL_THEME'] = CONFIGURE_QT.value('Material', 'theme', 'System')
+    os.environ['QT_QUICK_CONTROLS_MATERIAL_ACCENT'] = CONFIGURE_QT.value('Material', 'accent', 'Green')
+
+    if is_windows():
+        os.environ['QSG_RHI_BACKEND'] = 'opengl'
+
+    if is_linux():
+        os.environ['GDK_BACKEND'] = 'x11'
+        os.environ['QT_QPA_PLATFORM'] = 'xcb'
+
+    os.environ['QT_ENABLE_GLYPH_CACHE_WORKAROUND'] = '1'
+    os.environ['QML_USE_GLYPHCACHE_WORKAROUND'] = '1'
+
+    os.environ['QT_DEBUG_PLUGINS'] = CONFIGURE_QT.value('Develop', 'debug_plugin', '0')
--- a/artemis/utils/update_utils.py
+++ b/artemis/utils/update_utils.py
@@ -0,0 +1,222 @@
+import uuid
+import requests
+
+from packaging.version import Version
+
+from artemis.utils.constants import Constants, Messages
+from artemis.utils.sys_utils import is_windows, is_linux, is_macos, delete_file, match_hash, unpack_tar, open_file
+from artemis.utils.path_utils import DATA_DIR, TMP_DIR
+
+
+class UpdateManager:
+    """ Class used to manage DB and software updates
+    """
+
+    def __init__(self, parent):
+        self._parent = parent
+
+        self.db_update = None
+        self.art_update = None
+
+        self.remote_db_url = None
+        self.remote_db_hash = None
+        self.remote_db_version = None
+        self.remote_db_size = None
+        self.remote_db_file_name = None
+
+        self.remote_artemis_version = None
+        self.remote_artemis_url = None
+        self.remote_artemis_file_name = None
+
+        self.check_updates()
+
+
+    def check_updates(self, show_popup=False):
+        """ Checks if a software or DB update is available.
+            Prioritize Artemis updates over the DB one.
+
+            Args:
+                show_popup (bool, optional): 
+                    If False, suppress the "already up-to-date" message on startup.
+                    Defaults to False. True is usefull when the user manual check for
+                    updates.
+        """
+        latest_json = self.fetch_remote_json(Constants.LATEST_VERSION_URL, show_popup)
+        if latest_json:
+            local_db = self._parent.dbmanager.get_latest_local_sigid_db()
+            remote_db = latest_json['sigID_DB']
+
+            self.remote_db_version = remote_db['version']
+            self.remote_db_url = remote_db['url']
+            self.remote_db_hash = remote_db['sha256_hash']
+            self.remote_db_size = remote_db['total_bytes']
+            self.remote_db_file_name = self.remote_db_url.split('/')[-1]
+
+            if is_windows():
+                self.remote_artemis_version = latest_json['windows']['version']
+                self.remote_artemis_url = latest_json['windows']['url']
+            elif is_linux():
+                self.remote_artemis_version = latest_json['linux']['version']
+                self.remote_artemis_url = latest_json['linux']['url']
+            elif is_macos():
+                self.remote_artemis_version = latest_json['mac']['version']
+                self.remote_artemis_url = latest_json['mac']['url']
+            
+            self.remote_artemis_file_name = self.remote_artemis_url.split('/')[-1]
+
+            if Version(self.remote_artemis_version) > Version(Constants.APPLICATION_VERSION):
+                self.art_update = True
+            else:
+                self.art_update = False         
+
+            if self.art_update:
+                self._show_popup_art_update()
+            else:
+                if local_db:
+                    if self.remote_db_version > local_db.version:
+                        self._show_popup_db_update()
+                    elif show_popup:
+                        self._show_popup_up_to_date()
+                else:
+                    self._show_popup_initial_db_download()
+
+
+    def fetch_remote_json(self, url, show_popup=False):
+        """ Fetches the remote json from a url
+
+            Args:
+                show_popup (bool, optional): If false, suppress any error message
+                Defaults to False (to avoid error if the program is used offline)
+        """
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            if show_popup:
+                self._parent.dialog_popup(
+                    Messages.DIALOG_TYPE_ERROR,
+                    Messages.NO_CONNECTION,
+                    Messages.NO_CONNECTION_MSG.format(e)
+                )
+            return None
+
+
+    def download_db(self):
+        """ Open the downloader and download the sigID database in the 
+            TMP_DIR folder. After a succesfull download the callback function
+            from the downloader is post_download_db
+        """
+        self._parent.downloader.finished.connect(self.post_download_db)
+        self._parent.downloader.on_start(
+            self.remote_db_url,
+            TMP_DIR
+        )
+
+
+    def post_download_db(self):
+        """ After a succesfull DB download, this function check the hash
+            for possible corrupted data, delete old sigID DB and extract
+            the new one
+        """
+        latest_db_tar_path = TMP_DIR / self.remote_db_file_name
+        if match_hash(latest_db_tar_path, self.remote_db_hash):
+            db_dir_name = str(uuid.uuid4())
+            unpack_tar(latest_db_tar_path, DATA_DIR / db_dir_name)
+            self._parent.load_db(db_dir_name)
+            self._show_popup_db_download_complete()
+        else:
+            self._show_popup_db_hash_failed()
+        delete_file(latest_db_tar_path)
+
+
+    def download_artemis(self):
+        """ Open the downloader and download Artemis in the 
+            TMP_DIR folder. After a succesfull download the callback function
+            from the downloader is post_download_artemis
+        """
+        self._parent.downloader.finished.connect(self.post_download_artemis)
+        self._parent.downloader.on_start(
+            self.remote_artemis_url,
+            TMP_DIR
+        )
+
+
+    def post_download_artemis(self):
+        """ After a succesfull Artemis download, this open the installer
+            and close the application
+        """
+        if is_windows():
+            open_file(TMP_DIR / self.remote_artemis_file_name)
+            self._parent.close_ui.emit()
+
+
+    def _show_popup_db_update(self):
+        """ Prompts the user to download the updated version of the database
+        """
+        self._parent.dialog_download_db(
+            Messages.DIALOG_TYPE_WARN,
+            Messages.DB_NEW_VER,
+            Messages.DB_NEW_VER_MSG.format(self.remote_db_version)
+        )
+
+
+    def _show_popup_art_update(self):
+        """ Alerts the user of a new version of Artemis.
+            Windows - asks to download with automatic update
+            Linux, macOS - redirects to GitHub page
+        """
+        if is_windows():
+            self._parent.dialog_update_artemis(
+                Messages.DIALOG_TYPE_QUEST,
+                Messages.ART_NEW_VER,
+                Messages.ART_NEW_VER_AUTO_MSG.format(self.remote_artemis_version),
+                True
+            )
+        else:
+            self._parent.dialog_update_artemis(
+                Messages.DIALOG_TYPE_QUEST,
+                Messages.ART_NEW_VER,
+                Messages.ART_NEW_VER_MANUAL_MSG.format(self.remote_artemis_version),
+                False
+            )
+
+
+    def _show_popup_up_to_date(self):
+        """ Notifies the user that the database is up to date
+        """
+        self._parent.dialog_popup(
+            Messages.DIALOG_TYPE_INFO,
+            Messages.UP_TO_DATE,
+            Messages.UP_TO_DATE_MSG
+        )
+
+
+    def _show_popup_initial_db_download(self):
+        """ Prompts the user to download the database for the first time
+        """
+        self._parent.dialog_download_db(
+            Messages.DIALOG_TYPE_QUEST,
+            Messages.NO_DB_DETECTED,
+            Messages.NO_DB_DETECTED_MSG
+        )
+
+
+    def _show_popup_db_download_complete(self):
+        """ DB has been succesfully downloaded
+        """
+        self._parent.dialog_popup(
+            Messages.DIALOG_TYPE_INFO,
+            Messages.GENERIC_SUCCESS,
+            Messages.DB_DOWNLOAD_SUCCESS_MSG
+        )
+
+
+    def _show_popup_db_hash_failed(self):
+        """ Notify the user after detection of a corrupted database
+        """
+        self._parent.dialog_popup(
+            Messages.DIALOG_TYPE_ERROR,
+            Messages.DB_CORRUPTED,
+            Messages.DB_CORRUPTED_MSG
+        )
--- a/building/Linux/build_linux.sh
+++ b/building/Linux/build_linux.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+echo "Building Linux target ..."
+
+echo "Installing requirements ..."
+pip install -r requirements.txt
+pip install nuitka==2.4.10
+
+echo "Building with Nuitka ..."
+python -m nuitka app.py \
+  --standalone \
+  --show-modules \
+  --assume-yes-for-downloads \
+  --enable-plugin=pyside6 \
+  --noinclude-dlls=libQt6Charts* \
+  --noinclude-dlls=libQt6Quick3D* \
+  --noinclude-dlls=libQt6Sensors* \
+  --noinclude-dlls=libQt6Test* \
+  --noinclude-dlls=libQt6WebEngine* \
+  --include-qt-plugins=styles \
+  --include-qt-plugins=qml \
+  --include-qt-plugins=multimedia \
+  --include-data-files=./artemis/resources.py=./artemis/resources.py \
+  --include-data-files=./config/qtquickcontrols2.conf=./config/qtquickcontrols2.conf \
+  --include-data-files=./building/Linux/create_shortcut.sh=./create_shortcut.sh \
+  --include-data-files=./images/artemis_icon.svg=./images/artemis_icon.svg \
+  --force-stderr-spec="{TEMP}/artemis.err.log" \
+  --force-stdout-spec="{TEMP}/artemis.out.log"
+
+echo "Building Linux target finished."
--- a/spec_files/Linux/create_shortcut.sh
+++ b/spec_files/Linux/create_shortcut.sh
@@ -1,7 +1,7 @@
 clear
 echo "
    ===================================
-          Artemis 3 Shortcut Creator
+          Artemis 4 Shortcut Creator
                  LINUX
    ===================================
 "
@@ -15,7 +15,7 @@ sudo chmod 700 $DIR
 # Generation of shortcut
 file=/home/$USER/.local/share/applications/artemis.desktop
 if [ -e "$file" ]; then
-    echo "A shortcut of Artemis 3 is already present:"
+    echo "A shortcut of Artemis 4 is already present:"
    echo ""
    echo "R) Remove the shortcut and the icon file"
    echo "U) Update the shortcut"
@@ -26,16 +26,16 @@ if [ -e "$file" ]; then
        echo "[Desktop Entry]" >> /home/$USER/.local/share/applications/artemis.desktop
        echo "Name=Artemis" >> /home/$USER/.local/share/applications/artemis.desktop
        echo "Type=Application" >> /home/$USER/.local/share/applications/artemis.desktop
-        echo "StartupWMClass=artemis3" >> /home/$USER/.local/share/applications/artemis.desktop
-        echo "Exec=sh -c \"cd $DIR && ./Artemis\" " >> /home/$USER/.local/share/applications/artemis.desktop
+        echo "StartupWMClass=artemis" >> /home/$USER/.local/share/applications/artemis.desktop
+        echo "Exec=sh -c \"cd $DIR && ./app.bin\" " >> /home/$USER/.local/share/applications/artemis.desktop
        echo "Terminal=false" >> /home/$USER/.local/share/applications/artemis.desktop
-        echo "Icon=artemis3" >> /home/$USER/.local/share/applications/artemis.desktop
-        sudo cp ./artemis3.svg /usr/share/icons/
+        echo "Icon=artemis_icon" >> /home/$USER/.local/share/applications/artemis.desktop
+        sudo cp ./images/artemis_icon.svg /usr/share/icons/
        echo "Link Updated!"
    ;;
        r|R) 
        sudo rm /home/$USER/.local/share/applications/artemis.desktop
-        sudo rm /usr/share/icons/artemis3.svg
+        sudo rm /usr/share/icons/artemis_icon.svg
        echo "Link and icon removed!"
    ;;
        *) echo "Sorry! Invalid option $REPLY";;
@@ -44,14 +44,14 @@ else
    echo "[Desktop Entry]" >> /home/$USER/.local/share/applications/artemis.desktop
    echo "Name=Artemis" >> /home/$USER/.local/share/applications/artemis.desktop
    echo "Type=Application" >> /home/$USER/.local/share/applications/artemis.desktop
-    echo "StartupWMClass=artemis3" >> /home/$USER/.local/share/applications/artemis.desktop
-    echo "Exec=sh -c \"cd $DIR && ./Artemis\" " >> /home/$USER/.local/share/applications/artemis.desktop
+    echo "StartupWMClass=artemis" >> /home/$USER/.local/share/applications/artemis.desktop
+    echo "Exec=sh -c \"cd $DIR && ./app.bin\" " >> /home/$USER/.local/share/applications/artemis.desktop
    echo "Terminal=false" >> /home/$USER/.local/share/applications/artemis.desktop
-    echo "Icon=artemis3" >> /home/$USER/.local/share/applications/artemis.desktop
-    sudo cp ./artemis3.svg /usr/share/icons/
+    echo "Icon=artemis_icon" >> /home/$USER/.local/share/applications/artemis.desktop
+    sudo cp ./images/artemis_icon.svg /usr/share/icons/
    echo "
    Link copied in: /home/$USER/.local/share/applications/artemis.desktop
-    Icon copied in: /usr/share/icons/artemis3.svg
+    Icon copied in: /usr/share/icons/artemis_icon.svg
    "
 fi 

--- a/building/Windows/build_windows.ps1
+++ b/building/Windows/build_windows.ps1
@@ -0,0 +1,35 @@
+Write-Output "Building Windows target"
+
+Write-Output "Installing requirements ..."
+pip install -r requirements.txt
+pip install nuitka==2.4.10
+
+Write-Output "Building with Nuitka ..."
+python -m nuitka app.py `
+  --standalone `
+  --show-modules `
+  --assume-yes-for-downloads `
+  --windows-console-mode=disable `
+  --enable-plugin=pyside6 `
+  --noinclude-dlls="Qt6Charts*" `
+  --noinclude-dlls="Qt6Quick3D*" `
+  --noinclude-dlls="Qt6Sensors*" `
+  --noinclude-dlls="Qt6Test*" `
+  --noinclude-dlls="Qt6WebEngine*" `
+  --include-qt-plugins=styles `
+  --include-qt-plugins=qml `
+  --include-qt-plugins=multimedia `
+  --include-data-files=.\artemis\resources.py=.\artemis\resources.py `
+  --include-data-files=.\config\qtquickcontrols2.conf=.\config\qtquickcontrols2.conf `
+  --force-stderr-spec="{TEMP}\artemis.err.log" `
+  --force-stdout-spec="{TEMP}\artemis.out.log" `
+  --windows-company-name=Aresvalley.com `
+  --windows-product-name=Artemis `
+  --windows-file-version=4.1.0 `
+  --windows-product-version=4.1.0 `
+  --windows-file-description=Artemis `
+  --windows-icon-from-ico=images\artemis_icon.ico
+
+Rename-Item -Path app.dist\app.exe -NewName artemis.exe
+
+Write-Output "Building Windows target finished."
--- a/building/Windows/windows_installer.iss
+++ b/building/Windows/windows_installer.iss
@@ -0,0 +1,48 @@
+#define MyAppName "Artemis"
+#define MyAppVersion "4.1.0"
+#define MyAppPublisher "AresValley"
+#define MyAppURL "https://www.aresvalley.com/"
+#define MyAppExeName "artemis.exe"
+
+[Setup]
+AppName={#MyAppName}
+AppId={{2A04F9B8-0EF1-4D46-A335-E484DA6CE8A7}
+AppVersion={#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={autopf}\{#MyAppName}
+DisableProgramGroupPage=yes
+LicenseFile=..\..\LICENSE
+PrivilegesRequiredOverridesAllowed=dialog
+OutputDir=..\
+OutputBaseFilename=Artemis
+SetupIconFile=..\..\images\installer_icon.ico
+Compression=lzma2/ultra64
+SolidCompression=yes
+VersionInfoVersion={#MyAppVersion}
+ArchitecturesAllowed=x64
+UninstallDisplayIcon={app}\{#MyAppExeName}
+WizardStyle=modern
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+Source: "..\..\app.dist\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion
+Source: "..\..\app.dist\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Icons]
+Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
+
+[UninstallDelete]
+Type: filesandordirs; Name: "{localappdata}\{#MyAppPublisher}\{#MyAppName}\cache"
+Type: filesandordirs; Name: "{localappdata}\{#MyAppPublisher}\{#MyAppName}\config"
--- a/building/macOS/build_macos.sh
+++ b/building/macOS/build_macos.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+echo "Building maacOS target ..."
+
+echo "Installing requirements ..."
+pip install -r requirements.txt
+pip install nuitka==2.3 imageio
+
+echo "Building with Nuitka ..."
+python -m nuitka app.py \
+  --standalone \
+  --follow-imports \
+  --show-modules \
+  --assume-yes-for-downloads \
+  --enable-plugin=pyside6 \
+  --include-qt-plugins=sensible,styles,qml,multimedia \
+  --include-data-files=./artemis/resources.py=./artemis/resources.py \
+  --include-data-files=./config/qtquickcontrols2.conf=./config/qtquickcontrols2.conf \
+  --include-data-files=./building/Linux/create_shortcut.sh=./create_shortcut.sh \
+  --macos-create-app-bundle \
+  --macos-app-icon=images/artemis_icon.ico \
+  --macos-signed-app-name=com.AresValley.Artemis \
+  --macos-app-name=Artemis \
+  --macos-app-mode=gui \
+  --macos-sign-identity=ad-hoc \
+  --macos-app-version=4.1.0
+
+echo "Building Linux target finished."
--- a/config/qtquickcontrols2.conf
+++ b/config/qtquickcontrols2.conf
@@ -0,0 +1,13 @@
+[Controls]
+style=Material
+
+[Material]
+variant=Dense
+theme=System
+accent=Green
+
+[Database]
+autoload=0
+
+[Develop]
+debug_plugin=0
--- a/config/release-info.json
+++ b/config/release-info.json
@@ -0,0 +1,20 @@
+{
+  "sigID_DB": {
+    "version": 72,
+    "url": "https://github.com/AresValley/Artemis-DB/releases/download/v72/v72.tar",
+    "sha256_hash": "e41c211b0b51ad752404ffefe807638039b6386a6a21d8e5dac161f6143c95c5",
+    "total_bytes": 199249920
+  },
+  "windows": {
+    "version": "4.1.0",
+    "url": "https://github.com/AresValley/Artemis/releases/download/v4.1.0/Artemis-Windows-x86_64-4.1.0.exe"
+  },
+  "linux": {
+    "version": "4.1.0",
+    "url": "https://github.com/AresValley/Artemis/releases/download/v4.1.0/Artemis-Linux-x86_64-4.1.0.zip"
+  },
+  "mac": {
+    "version": "4.0.0",
+    "url": ""
+  }
+}
--- a/devel/env_script/start_linux.sh
+++ b/devel/env_script/start_linux.sh
@@ -0,0 +1,65 @@
+#!/bin/bash
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+if [[ "$(pwd)" =~ " " ]]; then echo This script relies on Miniconda which can not be silently installed under a path with spaces. && exit; fi
+
+OS_ARCH=$(uname -m)
+case "${OS_ARCH}" in
+    x86_64*)    OS_ARCH="x86_64";;
+    arm64*)     OS_ARCH="aarch64";;
+    *)          echo "Unknown system architecture: $OS_ARCH! This script runs only on x86_64 or arm64" && exit
+esac
+
+# config
+INSTALL_DIR="$(pwd)/installer_files"
+CONDA_ROOT_PREFIX="$(pwd)/installer_files/conda"
+INSTALL_ENV_DIR="$(pwd)/installer_files/env"
+MINICONDA_DOWNLOAD_URL="https://repo.anaconda.com/miniconda/Miniconda3-py310_23.1.0-1-Linux-${OS_ARCH}.sh"
+conda_exists="F"
+
+# figure out whether git and conda needs to be installed
+if "$CONDA_ROOT_PREFIX/bin/conda" --version &>/dev/null; then conda_exists="T"; fi
+
+# (if necessary) install git and conda into a contained environment
+# download miniconda
+if [ "$conda_exists" == "F" ]; then
+    echo "Downloading Miniconda from $MINICONDA_DOWNLOAD_URL to $INSTALL_DIR/miniconda_installer.sh"
+
+    mkdir -p "$INSTALL_DIR"
+    curl -Lk "$MINICONDA_DOWNLOAD_URL" > "$INSTALL_DIR/miniconda_installer.sh"
+
+    chmod u+x "$INSTALL_DIR/miniconda_installer.sh"
+    bash "$INSTALL_DIR/miniconda_installer.sh" -b -p $CONDA_ROOT_PREFIX
+
+    # test the conda binary
+    echo "Miniconda version:"
+    "$CONDA_ROOT_PREFIX/bin/conda" --version
+fi
+
+# create the installer env
+if [ ! -e "$INSTALL_ENV_DIR" ]; then
+    "$CONDA_ROOT_PREFIX/bin/conda" create -y -k --prefix "$INSTALL_ENV_DIR" python=3.10
+fi
+
+# check if conda environment was actually created
+if [ ! -e "$INSTALL_ENV_DIR/bin/python" ]; then
+    echo "Conda environment is empty."
+    exit
+fi
+
+# activate installer env
+source "$CONDA_ROOT_PREFIX/etc/profile.d/conda.sh" # otherwise conda complains about 'shell not initialized' (needed when running in a script)
+conda activate "$INSTALL_ENV_DIR"
+
+if [ ! -e "./Artemis" ]; then
+    git clone https://github.com/AresValley/Artemis.git
+    pip install -r Artemis/requirements/requirements.txt --user
+fi
+
+# setup installer env
+cd ./Artemis/src/
+python artemis.py
+
+echo
+echo "Done!"
--- a/devel/env_script/start_windows.bat
+++ b/devel/env_script/start_windows.bat
@@ -0,0 +1,56 @@
+@echo off
+
+cd /D "%~dp0"
+
+echo "%CD%"| findstr /C:" " >nul && echo This script relies on Miniconda which can not be silently installed under a path with spaces. && goto end
+
+set PATH=%PATH%;%SystemRoot%\system32
+
+@rem config
+set INSTALL_DIR=%cd%\installer_files
+set CONDA_ROOT_PREFIX=%cd%\installer_files\conda
+set INSTALL_ENV_DIR=%cd%\installer_files\env
+set MINICONDA_DOWNLOAD_URL=https://repo.anaconda.com/miniconda/Miniconda3-py310_23.1.0-1-Windows-x86_64.exe
+set conda_exists=F
+
+@rem figure out whether git and conda needs to be installed
+call "%CONDA_ROOT_PREFIX%\_conda.exe" --version >nul 2>&1
+if "%ERRORLEVEL%" EQU "0" set conda_exists=T
+
+@rem (if necessary) install git and conda into a contained environment
+@rem download conda
+if "%conda_exists%" == "F" (
+	echo Downloading Miniconda from %MINICONDA_DOWNLOAD_URL% to %INSTALL_DIR%\miniconda_installer.exe
+
+	mkdir "%INSTALL_DIR%"
+	call curl -Lk "%MINICONDA_DOWNLOAD_URL%" > "%INSTALL_DIR%\miniconda_installer.exe" || ( echo. && echo Miniconda failed to download. && goto end )
+
+	echo Installing Miniconda to %CONDA_ROOT_PREFIX%
+	start /wait "" "%INSTALL_DIR%\miniconda_installer.exe" /InstallationType=JustMe /NoShortcuts=1 /AddToPath=0 /RegisterPython=0 /NoRegistry=1 /S /D=%CONDA_ROOT_PREFIX%
+
+	@rem test the conda binary
+	echo Miniconda version:
+	call "%CONDA_ROOT_PREFIX%\_conda.exe" --version || ( echo. && echo Miniconda not found. && goto end )
+)
+
+@rem create the installer env
+if not exist "%INSTALL_ENV_DIR%" (
+  echo Packages to install: %PACKAGES_TO_INSTALL%
+  call "%CONDA_ROOT_PREFIX%\_conda.exe" create --no-shortcuts -y -k --prefix "%INSTALL_ENV_DIR%" python=3.10 || ( echo. && echo Conda environment creation failed. && goto end )
+  call pip install PySide6==6.5.0 requests
+)
+
+@rem check if conda environment was actually created
+if not exist "%INSTALL_ENV_DIR%\python.exe" ( echo. && echo Conda environment is empty. && goto end )
+
+@rem activate installer env
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" || ( echo. && echo Miniconda hook not found. && goto end )
+
+@rem setup installer env
+call python app.py
+
+echo.
+echo Done!
+
+:end
+pause
--- a/docs/acf_analysis.md
+++ b/docs/acf_analysis.md
@@ -0,0 +1,71 @@
+# Autocorrelation Function (ACF)
+
+## Theoretical Introduction
+
+Correlation functions are valuable mathematical tools utilized across various scientific disciplines, including engineering, physics, and chemistry. The cross-correlation function, commonly defined as a sliding inner (dot) product, quantifies the similarity between two signals as a function of a temporal shift applied to one of them:
+
+$$
+\left[ k*l \right]\equiv \int_{-\infty}^{+\infty}k^{*}(t)l(t+\tau)dt
+$$
+
+where $k$ and $l$ are two general non-discrete functions without discontinuity, $k^{*}$ is the complex conjugate of $k$ and $\tau$ is the lag (time delay for signal analysis). This representation is closely related to the convolution theorem by the following relationship:
+
+$$
+k(t)*l(t)\equiv k^{*}(-t)*l(t)
+$$
+
+In our case, the signal must be compared with itself to identify periodic patterns or detect anomalous high degrees of similarity within a given time interval. To achieve this objective, we can employ the Autocorrelation Function (ACF), which is essentially the cross-correlation of a signal with itself, where $k(t)=l(t)$. The following equation defines the ACF, derived from a straightforward modification of the initial equation:
+
+$$
+\left[ k*k \right](\tau)\equiv \int_{-\infty}^{+\infty}k^{*}(t)k(t+\tau)dt
+$$
+
+Within a discrete data set composed by $Y(t)$ records we can easily calculate autocorrelation from:
+
+$$
+\rho_{\tau}=\frac{\sum_{i=1}^{N-\tau}(Y_i-\bar{Y})(Y_{i+\tau}-\bar{Y})}{\sum_{i=1}^{N}(Y_i-\bar{Y})^2}
+$$
+
+where $Y_{i+τ}$ is a lagged data by $τ$ of $Y_i$ and $\bar{Y}$ is the average value of the original data set. Entire denominator is used to keep the normalization condition, indeed ρτ can assume a value between -1 (exact anticorrelation) and +1 (exact correlation). A complete correlation can be only achieved with a perfect overlap of the analyzed function with it self; the simple way to verify that is when $τ=0$
+
+![Screenshot](assets/acf_1.png)
+
+## Example: ACF Analysis
+### STANAG 4285
+
+The first example will be a NATO standard known as STANAG 4285. You can download a .wav sample from [:material-download: HERE](assets/stanag_4285.wav). 
+
+<div align="center">
+    <audio controls>
+        <source src="https://raw.githubusercontent.com/AresValley/Artemis/master/docs/assets/stanag_4285.wav" type="audio/wav">
+        Your browser does not support the audio player.
+    </audio>
+</div>
+
+We start to collect some information about the structure of this signal: a good starting point is the official declassified NATO document dated 1989. The main frame structure can be found at **Annex A-3/5** with a graphical view at **Annex A-7**, also reported below:
+
+* [STANAG 4285 (i)](assets/acf_2.png)
+* [STANAG 4285 A-3](assets/acf_3.png)
+* [STANAG 4285 A-4](assets/acf_4.png)
+* [STANAG 4285 A-5](assets/acf_5.png)
+* [STANAG 4285 A-7](assets/acf_6.png)
+
+!!! note "Summary"
+    * 1 x 80 bits of synchronization pattern
+    * 4 x 32 bits of data
+    * 3 x 16 bits of reference
+
+Therefore, a full sequence will be composed as the sum of all symbols reported above: 256 symbols recursively transmitted at the ratio of 2400 bauds means a redundancy of 106.66 ms.
+To analyze an unknown signal I strongly recommend **Signal Analyzer (SA)**. SA is actually one of the most valuable and priceless software available by Sergey Makarov (Макаров Сергей Михайлович, sadly passed away on 29 May 2012) and it used to perform several tests on data sample coded as .wav or .mp3 file. The signal waterfall is reported below:
+
+![Screenshot](assets/acf_7.png)
+
+When an Autocorrelation function is applied on selected data frame (see above), the result shows a clear recursive pattern with a gap of **106.244 ms** between every peak as expected. An ACF refinement can be done into **WaveForm** windows where we can also notice an identical structure as reported by the specifications
+
+![Screenshot](assets/acf_8.png)
+![Screenshot](assets/acf_9.png)
+
+!!! Success "Summary"
+    1. Synchronization pattern is composed by $2400*33.013E-3=79.2\simeq 80$ symbols
+    2. Data group contain $2400*13.348E-3=32.0=32$ symbols
+    3. Reference sequence is formed by $2400*6.674E-3=16.02\simeq 16$ symbols
--- a/docs/assets/HMIB.webp
+++ b/docs/assets/HMIB.webp
--- a/docs/assets/HMID.webp
+++ b/docs/assets/HMID.webp
--- a/docs/assets/HMII.webp
+++ b/docs/assets/HMII.webp
--- a/docs/assets/acf_1.png
+++ b/docs/assets/acf_1.png
--- a/docs/assets/acf_2.png
+++ b/docs/assets/acf_2.png
--- a/docs/assets/acf_3.png
+++ b/docs/assets/acf_3.png
--- a/docs/assets/acf_4.png
+++ b/docs/assets/acf_4.png
--- a/docs/assets/acf_5.png
+++ b/docs/assets/acf_5.png
--- a/docs/assets/acf_6.png
+++ b/docs/assets/acf_6.png
--- a/docs/assets/acf_7.png
+++ b/docs/assets/acf_7.png
--- a/docs/assets/acf_8.png
+++ b/docs/assets/acf_8.png
--- a/docs/assets/acf_9.png
+++ b/docs/assets/acf_9.png
--- a/docs/assets/aia_0094.webp
+++ b/docs/assets/aia_0094.webp
--- a/docs/assets/aia_0131.webp
+++ b/docs/assets/aia_0131.webp
--- a/docs/assets/aia_0171.webp
+++ b/docs/assets/aia_0171.webp
--- a/docs/assets/aia_0193.webp
+++ b/docs/assets/aia_0193.webp
--- a/docs/assets/aia_0304.webp
+++ b/docs/assets/aia_0304.webp
--- a/docs/assets/aia_0335.webp
+++ b/docs/assets/aia_0335.webp
--- a/docs/assets/aia_1600.webp
+++ b/docs/assets/aia_1600.webp
--- a/docs/assets/aia_1700.webp
+++ b/docs/assets/aia_1700.webp
--- a/docs/assets/artemis_icon.ico
+++ b/docs/assets/artemis_icon.ico
--- a/docs/assets/artemis_preview.webp
+++ b/docs/assets/artemis_preview.webp
--- a/docs/assets/lasco_c2.webp
+++ b/docs/assets/lasco_c2.webp
--- a/docs/assets/lasco_c3.webp
+++ b/docs/assets/lasco_c3.webp
--- a/docs/assets/logo_large_black.svg
+++ b/docs/assets/logo_large_black.svg
--- a/docs/assets/logo_large_white.svg
+++ b/docs/assets/logo_large_white.svg
--- a/docs/assets/logo_small_black.svg
+++ b/docs/assets/logo_small_black.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="222.267" height="371.88" viewBox="0 0 166.7 278.91" fill="#231f20" xmlns:v="https://vecta.io/nano"><path d="M0 140.2L83.35 0l83.35 140.2-25.74 43.28-16.55-27.43c2.98-5.36 6.25-10.54 9.33-15.84L83.35 55.44 32.96 140.2l9.34 15.79-16.52 27.47L0 140.2zm37.52 62.49l45.83-76.19 45.83 76.18-45.83 76.23-45.83-76.22z"/></svg>
--- a/docs/assets/logo_small_white.svg
+++ b/docs/assets/logo_small_white.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="222.267" height="371.88" viewBox="0 0 166.7 278.91" fill="#231f20" xmlns:v="https://vecta.io/nano"><path d="M0 140.2L83.35 0l83.35 140.2-25.74 43.28-16.55-27.43c2.98-5.36 6.25-10.54 9.33-15.84L83.35 55.44 32.96 140.2l9.34 15.79-16.52 27.47L0 140.2zm37.52 62.49l45.83-76.19 45.83 76.18-45.83 76.23-45.83-76.22z" fill="#fff"/></svg>
--- a/docs/assets/main_window.webp
+++ b/docs/assets/main_window.webp
--- a/docs/assets/sql_schema.webp
+++ b/docs/assets/sql_schema.webp
--- a/docs/assets/ssa_1.webp
+++ b/docs/assets/ssa_1.webp
--- a/docs/assets/stanag_4285.wav
+++ b/docs/assets/stanag_4285.wav
--- a/docs/assets/sw_1.webp
+++ b/docs/assets/sw_1.webp
--- a/docs/assets/sw_2.webp
+++ b/docs/assets/sw_2.webp
--- a/docs/assets/sw_3.webp
+++ b/docs/assets/sw_3.webp
--- a/docs/assets/sw_4.webp
+++ b/docs/assets/sw_4.webp
--- a/docs/basic_operations.md
+++ b/docs/basic_operations.md
@@ -0,0 +1,109 @@
+#
+
+![sw_current](assets/main_window.webp)
+
+## 1. Main Menu
+
+### File
+
+* **New Database**
+
+    Create a new database.
+
+* **Load Database** 
+
+    Open the Database Manager windows in order to open, rename, or delete a database.
+
+* **Import Database** 
+
+    Import an Artemis database with a standard .tar format.
+    !!! tip "Offline Importing of SigID Database"
+        Sometimes it may happen that a computer does not have network access and unfortunately Artemis cannot download the SigID database. To solve this you can:
+
+        1. Download the .tar database [:material-download: HERE](https://github.com/AresValley/Artemis-DB/releases) from a PC with an internet access
+        2. Import the downloaded .tar on the target PC (without internet access) using the **Import Database** function
+
+* **Export Database** 
+
+    Export the loaded database with a standard .tar format.
+
+* **Edit Tags** 
+
+    Open the tags editor window. From here, you can add, rename, or delete tags. The tags can be added to a signal from the [tags menu](#4-tags)
+
+* **Open Database Folder**
+
+    Shows the folder of the currently loaded database in the explorer.
+
+* **Preferences**
+
+    Open the program settings window.
+
+* **Exit**
+
+    This will close the application.
+
+### Signal
+* **New**
+
+    Add a new signal to the database.
+
+* **Edit**
+
+    Edit the current/selected signal from the loaded database.
+
+### Space Weather
+
+* **Check Report**
+
+    Open the main [Space Weather window](space_weather/current.md) and retrieve all the live data from Poseidon Crawler.
+
+## 2. Signal List
+This is the signal list where all the database entries are shown. When a signal is selected, it will load on the right panel.
+
+### Filter by Name/Description
+On top of the list, there is a field for filtering signals by name or any keyword inside the description of the signal: this filter has the highest priority among all the filters.
+
+## 3. Signal Menu
+Here you can swithc between the main **signal** window and the **filter** page.
+
+## 4. Tags
+
+* **Associate Tag**
+
+    Custom tags can be associated to the selected signal with the :octicons-plus-circle-16: icon
+
+* **Remove Tag**
+
+    In order to remove a tag, just click on its badge.
+
+* **Add/Rename Tag**
+
+    To add a new tag open the [Tags Editor](#1-main-menu) in the main menu.
+
+## 5. Add Parameter
+Click on the labels to add the corresponding parameter to the signal (e.g. click on **Frequency** to add a new frequency).
+
+## 6. Edit Parameter
+Click on the parameter badge to open the Signal Editor windows. From here, you can edit or delete the corresponding parameter.
+
+!!! tip "Parameter Description"
+    All the parameters have a description field: if some text is added, it will appear when the corresponding parameter badge is hovered with the mouse pointer.
+
+## 7. Description :simple-markdown:{ title="Markdown Supported" }
+This is the description of the signal and can be edited from the [Main Menu](#1-main-menu) (`Signal/Edit...`)
+
+!!! tip "Markdown Supported"
+    The Description field can render **Markdown**, a simple markup language for creating rich text using plain text. Headers, emphasis, lists, links, code blocks, and many more features for advanced text formatting. [Markdown Basic Syntax :simple-markdown:](https://www.markdownguide.org/basic-syntax/)
+
+## 8. Audio Sample
+This is a player where an audio sample of the signal can be played. To associate an audio file to be shown as the **main** audio sample, check in the [extra menu](#10-extra) below the signal spectrum.
+
+## 9. Image Sample
+This is an image box that commonly contains the signal spectrum/waterfall. To associate an image file to be shown as the **main** image sample, check in the [extra menu](#10-extra) below the signal spectrum.
+
+## 10. Extra
+
+:material-earth: This button is only available for the standard SigID wiki database and connects the local signal to its counterpart on the [sigidwiki website](https://www.sigidwiki.com/).
+
+:material-file-document-multiple: This will open the **Documents Manager**. From here you can add any file (audio, image, pdf, etc.) to the signal entry. It is also possible to mark only one image and one audio to be shown on the main signal window.
--- a/docs/build_package.md
+++ b/docs/build_package.md
@@ -0,0 +1,51 @@
+# Build Package
+Building a distributable package with an executable for Artemis creates a practical solution for end-users, as they can run the application without needing to interact with the terminal and they can easily share the application as a standalone package.
+
+## Requirements
+* Python (3.11 or higher)
+
+!!! info
+    We assume that Python is already installed on the system and the Artemis source code has been downloaded and extracted. If these prerequisites are not met, please follow steps 1 to 3 in the [run from source section](run_from_source.md).
+
+!!! warning "Cross-Compilation"
+    An operating system that matches the target OS must be used to generate standalone packages, as Nuitka does not support cross-compilation. For example, you cannot build binaries on Windows that work on Linux or macOS.
+
+## :simple-windows: Windows
+
+### Procedure
+
+1. Open a PowerShell terminal in the main Artemis folder and execute the following command to start the build process:
+
+    ```
+    .\building\Windows\build_windows.ps1
+    ```
+
+2. Wait for the build process to complete. This may take a few minutes depending on your system's performance. Once the process finishes, check the `artemis.dist/` directory: it will contain the standalone software with the `artemis.exe` executable.
+
+---
+
+## :simple-linux: Linux
+
+### Procedure
+
+1. Open a terminal in the main Artemis folder and execute the following command to start the build process:
+    ```
+    . ./building/Linux/build_linux.sh
+    ```
+
+2. Wait for the build process to complete. This may take a few minutes depending on your system's performance. Once the process finishes, check the `artemis.dist/` directory: it will contain the standalone software with the `app.bin` executable.
+3. If you wish to create a shortcut, follows the procedure in the [installation section](installation.md/#create-a-shortcut)
+
+---
+
+## :simple-apple: Mac OS
+
+!!! warning
+    The support for the macOS compiled version of the program is temporarily limited due to a lack of machines for extensive testing. Feel free to contribute by reporting any issues you encounter by [opening an Issue](https://github.com/AresValley/Artemis/issues).
+
+### Procedure
+
+1. Open a terminal in the main Artemis folder and execute the following command to start the build process:
+    ```
+    . ./building/macOS/build_macos.sh
+    ```
--- a/docs/contribute.md
+++ b/docs/contribute.md
@@ -0,0 +1,37 @@
+# Contribute
+Artemis is an open-source project, and every contribution, no matter how small, is valuable and greatly appreciated. Don't worry about getting everything perfect; we are happy to work with you on your contribution and help you along the way. This guide will help you get started by outlining various ways you can contribute.
+
+<div class="grid cards" markdown>
+
+- :material-bug: __Spot a bug?__
+
+    ---
+
+    Please open an issue (or pull request) and let us know the problem you faced (or you're working on)
+
+    [:octicons-arrow-right-24: Open an Issue](https://github.com/AresValley/Artemis/issues)
+
+- :material-source-fork: __Fork the repository__
+
+    ---
+
+    Create a copy of the codebase from which you can modify and submit pull requests.
+
+
+    [:octicons-arrow-right-24: Fork the repo](https://github.com/AresValley/Artemis)
+
+- :material-lightbulb-on: __Ideas?__
+
+    ---
+
+    Idea for a new feature? Open an issue on the project's GitHub repository to describe your proposal.
+
+    [:octicons-arrow-right-24: Open an Issue](https://github.com/AresValley/Artemis/issues)
+
+- :material-heart: __Spreading the word!__
+
+    ---
+
+    Do you like Artemis? Remember to share it with your network and your friends!
+
+</div>
--- a/docs/credits.md
+++ b/docs/credits.md
@@ -0,0 +1,14 @@
+# License & Credits
+
+## License
+Artemis is maintained by Marco Dalla Tiezza and released under the [GPLv3](https://github.com/AresValley/Artemis/blob/master/LICENSE) license.
+
+## Credits
+* **Marco Dalla Tiezza** - *Artemis I-II-IV developer, DB parsing, Website*
+* [**Alessandro Ceccato**](https://github.com/alessandro90 "GitHub profile") - *Artemis III lead developer*
+* **Paolo Romani (IZ1MLL)** - *Lead β Tester, RF specialist*
+* **Carl Colena** - *Sigidwiki admin, β Tester, Signals expert*
+* [**Marco Bortoli**](https://github.com/marbort "GitHub profile") - *macOS deployment, β Tester*
+* [**Eric Wiessner (KI7POL)**](https://github.com/WheezyE "GitHub profile") - *ARM port (Raspberry Pi3B+ and Pi4B)*
+* [**Pierpaolo Pravatto**](https://github.com/ppravatto "GitHub profile") - *Wiki page, β Tester*
+* [**Francesco Capostagno**](https://github.com/fcapostagno "GitHub profile"), **Luca**, **Pietro** - *β Tester*
--- a/docs/database/db_acf.md
+++ b/docs/database/db_acf.md
@@ -0,0 +1,25 @@
+# ACF
+The table contains 4 columns explained below.
+
+!!! example
+    A technical explanation on how autocorrelation function works along with a practical example is reported [HERE](../acf_analysis.md)
+
+## ACF_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new ACF. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the ACF. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`FLOAT`
+
+The autocorrelation time expressed in ms.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the details about the autocorrelation value, e.g. `Frame`, `Superframe`, etc.
--- a/docs/database/db_bandwidth.md
+++ b/docs/database/db_bandwidth.md
@@ -0,0 +1,22 @@
+# Bandwidth
+The table contains 4 columns explained below.
+
+## BAND_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new bandwidth. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the bandwidth. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`INTEGER`
+
+The bandwidth in Hz expressed as an integer.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the purpose of the bandwidth and any other useful details.
--- a/docs/database/db_cat_label.md
+++ b/docs/database/db_cat_label.md
@@ -0,0 +1,12 @@
+# Category Label
+This table contains only the name of the category/tag. The table contains 2 columns explained below.
+
+## CLB_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new category tag. It is auto-incrementing and is not replaced in the event of deletion.
+
+## VALUE
+`TEXT`
+
+The name of the category/tag expressed as a string.
--- a/docs/database/db_category.md
+++ b/docs/database/db_category.md
@@ -0,0 +1,17 @@
+# Category
+The primary function of this table is to facilitate the classification of the signal by assigning it to its appropriate family or category. Can be used with any tag. The table contains 3 columns explained below.
+
+## CAT_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new category/tag. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the category. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## CLB_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific **category label** associated with the category. It links to the primary key of the [Category Label](db_cat_label.md) table that holds the name of the category.
--- a/docs/database/db_frequency.md
+++ b/docs/database/db_frequency.md
@@ -0,0 +1,22 @@
+# Frequency
+The table contains 4 columns explained below.
+
+## FREQ_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new frequency. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the frequency. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`INTEGER`
+
+The freqeuncy in Hz expressed as an integer.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the purpose of the bandwidth and any other useful details.
--- a/docs/database/db_info.md
+++ b/docs/database/db_info.md
@@ -0,0 +1,26 @@
+# Info
+This is the database meta table and contains 4 columns explained below.
+
+## NAME
+`TEXT`
+
+This is the name of the database.
+
+## DATA
+`TEXT`
+
+The creation date when the database has been initialised.
+
+## VERSION
+`INTEGER`
+
+A simple integer to denote the database version.
+
+## EDITABLE
+`INTEGER`
+
+This field should serve as a writing protection on the database.
+
+* **-1**: reserved to sigID database. This is the primary way to distinguish a valid sigID database
+* **0**: read-only database
+* **1**: database can be edited with no restrictions
--- a/docs/database/db_location.md
+++ b/docs/database/db_location.md
@@ -0,0 +1,22 @@
+# Location
+This is the location where the signal is distributed/received. Avoid the usage of the precise location of the TX station or very small town (very rare). It's a good habit to use **nations/continents** or special location (like `Worldwide`). The table contains 4 columns explained below.
+
+## LOC_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new location. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the location. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`TEXT`
+
+The location expressed as a string.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain further details about the location.
--- a/docs/database/db_mode.md
+++ b/docs/database/db_mode.md
@@ -0,0 +1,22 @@
+# Mode
+This field reports the way how a signals has been decoded during the reception. The table contains 4 columns explained below.
+
+## MOD_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new mode. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the modulation. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`TEXT`
+
+The mode expressed as a string.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the purpose of the mode and any other useful details.
--- a/docs/database/db_modulation.md
+++ b/docs/database/db_modulation.md
@@ -0,0 +1,22 @@
+# Modulation
+Modulation refers to the method by which information is encoded into the main signal (carrier). This process involves altering various properties of the carrier signal, such as amplitude, frequency, or phase. Multiple modulation techniques can be employed, and a TX station has the capability to utilize different modulation schemes. The table contains 4 columns explained below.
+
+## MDL_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a new modulation. It is auto-incrementing and is not replaced in the event of deletion.
+
+## SIG_ID
+`INTEGER` :material-axis-arrow:{ title="Foreign key" }
+
+This is a direct reference to the specific signal associated with the modulation. It links to the primary key of the [Signals](db_signals.md) table that holds detailed information about the signals.
+
+## VALUE
+`TEXT`
+
+The modulation expressed as a string.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the purpose of the modulation and any other useful details.
--- a/docs/database/db_overview.md
+++ b/docs/database/db_overview.md
@@ -0,0 +1,8 @@
+# Database
+
+With the release of Artemis 4, we have made a significant upgrade in our data management system by transitioning from a CSV file to a full relational SQL database. This change brings a multitude of advantages that enhance the efficiency, scalability, and reliability of our system. In the following sections, we will explore, table by table, the structure of the new database.
+
+![Screenshot](../assets/sql_schema.webp)
+
+
+
--- a/docs/database/db_signals.md
+++ b/docs/database/db_signals.md
@@ -0,0 +1,28 @@
+# Signals
+This is the main table and contains 4 columns explained below.
+
+## SIG_ID
+`INTEGER` :material-key-outline:{ title="Primary key" } :material-upload-outline:{ title="Auto-increment" }
+
+This is a unique identification number for each entry that is assigned during the creation of a signal. It is auto-incrementing and is not replaced in the event of signal deletion.
+
+## NAME
+`TEXT`
+
+The name of the signal. A simple string that describes in short the analyzed signal. Special characters are allowed.
+
+## DESCRIPTION
+`TEXT`
+
+The short description is used to explain the purpose of the signal and some other useful details.
+
+!!! tip
+    The DESCRIPTION field supports **Markdown**, a simple markup language for creating rich text using plain text. Headers, emphasis, lists, links, code blocks and many more features for advanced text formtting. [Markdown Basic Syntax :simple-markdown:](https://www.markdownguide.org/basic-syntax/)
+
+## URL
+`TEXT`
+
+The sigidwiki (SigID) URL of the selected signal. This is a direct connection to the online database where further details of the signal are collected.
+
+!!! info
+    **Internal Use Only** This field is for the SigID database and not intended for user viewing or editing. Personal URLs can be stored in the signal description.
--- a/docs/database/sigid.md
+++ b/docs/database/sigid.md
@@ -0,0 +1,55 @@
+# SigID Wiki Database
+
+<div align="center" markdown>
+
+  ![GitHub Release](https://img.shields.io/github/v/release/AresValley/Artemis-DB?label=Latest%20release)
+  ![GitHub repo file or directory count (in path)](https://img.shields.io/github/directory-file-count/aresvalley/artemis-db/static?type=dir&label=DB%20signals)
+  ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/AresValley/Artemis-DB/total?label=DB%20requests)
+  ![GitHub Release Date](https://img.shields.io/github/release-date/AresValley/Artemis-DB)
+
+</div>
+
+Artemis serves as a valuable resource for both personal signal collection and leveraging a vast repository of pre-identified signals. This software application allows users to curate their own collections, but its true strength lies in its integration with a comprehensive database of known signals. This database is directly sourced from the [Signal Identification Wiki](https://www.sigidwiki.com/wiki/Signal_Identification_Guide), an open-source resource collaboratively maintained by a global community of radio enthusiasts.
+
+!!! tip "Database Revision"
+    For quality control purposes, the database undergoes a rigorous review process before integration into Artemis. This review adheres to established [guidelines](https://github.com/AresValley/Artemis-DB), ensuring the accuracy and completeness of the information presented to users. The specifics of this review process are outlined in the following section.
+
+## Modulation
+A good practise (reported also on ) is to write the primary type of modulation (if known) and not all the possible variants. A practical example is reported on [Signal Identification Wiki](https://www.sigidwiki.com/wiki/Signal_Identification_Guide): there is no need to write **8-PSK** or **QPSK**, **PSK** is enough. The Artemis SigID database is provided without any modulation variants included. The recognized modulations are listed below:
+
+### Analog
+* **AM:** Amplitude Modulation
+* **FM:** Frequency Modulation
+* **PM:** Phase Modulation
+* **LSB:** Lower Sideband
+* **USB:** Upper Sideband
+* **VSB:** Vestigial Sideband
+* **CW:** Continuous Wave
+  
+### Digital
+* **QAM:** Quadrature Amplitude Modulation
+* **PSK:** Phase-Shift Keying
+* **FSK:** Frequency-Shift Keying
+* **ASK:** Amplitude-Shift Keying
+* **MSK:** Minimum-Shift Keying
+* **IFK:** Incremental Frequency Keying
+* **OOK:** On-Off Keying
+* **FDM:** Frequency-Division Multiplexing
+* **BOC:** Binary Offset Carrier Modulation
+* **CDMA:** Code Division Multiple Access
+* **TDMA:** Time Division Multiple Access
+* **FBMC:** Filter Bank Multi Carrier
+* **UFMC:** Universal Filtered Multi Carrier
+* **PCM:** Pulse Code Modulation
+* **PPM:** Pulse Position Modulation
+* **FMCW:** Frequency-Modulated Continuous Wave
+* **Pulse:** Pulse
+
+### Spread Spectrum
+* **CSS:** Chirp Spread Spectrum
+* **DSSS:** Direct Sequence Spread Spectrum
+* **FHSS:** Frequency Hopping Spread Spectrum
+* **THSS:** Time Hopping Spread Spectrum
+
+## Locations
+Locations are either countries or special token (`Worldwide`, `Europe`, etc.) . Precise location of the TX station, towns and cities are converted to their respective countries.
--- a/docs/faq.md
+++ b/docs/faq.md
@@ -0,0 +1,18 @@
+# Frequently Asked Questions
+
+### What about an automatic signal recognition feature?
+This question has been asked countless times, and for good reason: in many fields, machine learning (ML) has disrupted the way we solve problems, and when applied to the right field, you can get outstanding results. **So why not on signals?**
+
+Well, the story dates back to at least 2017 when I started discussing it with several people on the rtl-sdr blog: at first, it seemed promising, but like many things, all that glitters is not gold. Let us proceed in order: 
+
+#### ML / Deep Learning approach
+A machine learning/neural network approach would not be complex (from a technical standpoint) if there were not the problem of the dataframe completeness. To be effective, neural models need to be trained on a large number of entries. The precise number can vary and strongly depends on the nature of data used for training, but commonly, numbers can be tens of thousands of entries or even more, for example. This would not be a significant concern in the case of RF signals because the various encodings that differentiate can be created artificially using for example [Fldigi](http://www.w1hkj.com/). To make these synthetic signals more like a real one, noise and artificial distortions can be added. However, this approach allows us to have a spectrum that ranges only over civilian, non-proprietary, and non-military signals (a little bit more than 150 out of 500, in the best-case scenario). Many efforts have been made in this field and some excellent results have been reported below:
+
+- [O’Shea, Corgan, and Clancy](https://arxiv.org/pdf/1602.04105) - Training Size: 900000 signals, 11 modulations
+- [Stefan Scholl](https://arxiv.org/pdf/1906.04459) - Training Size: 120000 signals, 18 modulations
+- [Stefan Scholl](https://panoradio-sdr.de/automatic-identification-of-160-shortwave-rf-signals-with-deep-learning/) - Training Size: 1.2 million signals, 143 modulations tested in HF
+
+Therefore, The main point is to have a good quality data frame to train the model; this is not always an easy task for the above reasons. Subsequently, as Stefan Scholl pointed out on his blog, similar modulations (MFSK-32 vs Olivia 16/500) can significantly decrease the effectiveness of discrimination. The quality of reception can also influence the result as well:  high SNR cannot always be an ideal point since the reception can be disrupted by interference or fading.
+
+#### Classical Audio Analysis
+More classical methods, such as similarity recognition between audio samples (such as using Mel-frequency cepstral coefficients, for example), could be effective, albeit marginally, if applied to the 500 signals audio sample library from sigID wiki. With the same signal encoding, the content of the signal alone can affect the similarity index and, thus, the method's effectiveness. Listening to a signal with the same modulation but encoding different information can significantly decrease the accuracy of signal recognition.
--- a/docs/index.md
+++ b/docs/index.md
@@ -0,0 +1,14 @@
+---
+title: Documentation
+---
+#
+
+<div align="center">
+    <iframe width="560" height="315" src="https://www.youtube.com/embed/W_8Y_4FvoHI?si=0hBqRnxnzCUWmTxK" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+</div>
+
+<p align="center" markdown>
+    [Artemis Homepage](https://www.aresvalley.com){ .md-button }
+</p>
+
+**Artemis** is a software designed to assist **radio frequency (RF) signal identification and storage**. It simplifies real-time spectrum analysis by leveraging one of the most extensive and community-driven databases, containing over **520 recognized signals**. This comprehensive software solution allows users to collect RF signals with specific parameters such as frequency, bandwidth, modulation, etc. Users can also store spectrum waterfalls, audio samples, and all types of documents for future reference. Artemis provides a robust platform to manage a wide range of RF data with precision and ease.
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -0,0 +1,53 @@
+# Installation
+
+**Requirements:**
+
+* **Windows** 8 or later
+* **Linux** Ubuntu 20.04+ / Mint 20+ / Fedora 32+ and many other
+* **macOS** 11+ (Big Sur or later)
+
+## :simple-windows: Windows
+1. Download the installer `Artemis-Windows-x86_64-4.x.x.exe` in the Assets menu from the [:material-download: LATEST RELEASE](https://github.com/AresValley/Artemis/releases) and follow the guided procedure to complete the installation process.
+
+---
+
+## :simple-linux: Linux
+1. On Linux, the xcb plugin is utilized to supply the essential functionality required for Qt GUI and Qt Widgets to operate on [X11](https://doc.qt.io/qt-6/linux-requirements.html). On some Linux distributions the required dependencies are already met, but in many cases, you will need to install them. To install the dependencies use:
+
+    ``` bash title="Debian-based distro (Ubuntu, Mint, Pop! OS, Kali, ...)"
+    sudo apt install libxcb-*
+    ```
+
+2. Download `Artemis-Linux-x86_64-4.x.x.tar` in the Assets menu from the [:material-download: LATEST RELEASE](https://github.com/AresValley/Artemis/releases) and extract the tarball archive in a folder of your choice.
+3. Before running `app.bin`, be sure to have the executable permissions to the binary file with:
+
+    ```
+    chmod 700 app.bin
+    ```
+
+### Create a Shortcut
+
+1. To create a direct shortcut (in the main menu) launch the bash script in the terminal with the command:
+
+    ```
+    . create_shortcut.sh
+    ```
+
+This script will:
+
+- Set the correct read/write privileges of the Artemis folder
+- Create the artemis.desktop file (shortcut) in /home/$USER/.local/share/applications
+- Move the Artemis icon file to /usr/share/icons
+
+---
+
+## :simple-apple: Mac OS
+!!! warning
+    The macOS support is temporarily limited!
+
+The support for the macOS compiled version of the program is temporarily limited due to a lack of machines for extensive testing. To use Artemis on a macOS device, you have the following options:
+
+* **Run the program directly from the source:** Follow the instructions provided in [this chapter](run_from_source.md) to launch the program from the source code.
+* **Compile the Artemis 4 binaries on your machine:** In this case, you can contribute by reporting any issues you encounter by [opening an Issue](https://github.com/AresValley/Artemis/issues).
+* **Use the last available compiled version (3.2.1):** Although this version is no longer officially supported, it remains available for use: [:material-download: Artemis-3.2.1.dmg](https://www.aresvalley.com/?sdm_process_download=1&download_id=377).
+
--- a/docs/javascripts/katex.js
+++ b/docs/javascripts/katex.js
@@ -0,0 +1,10 @@
+document$.subscribe(({ body }) => { 
+    renderMathInElement(body, {
+      delimiters: [
+        { left: "$$",  right: "$$",  display: true },
+        { left: "$",   right: "$",   display: false },
+        { left: "\\(", right: "\\)", display: false },
+        { left: "\\[", right: "\\]", display: true }
+      ],
+    })
+  })
--- a/docs/run_from_source.md
+++ b/docs/run_from_source.md
@@ -0,0 +1,44 @@
+# Run from source code
+Running Artemis directly from the source code using the Python interpreter is considered the most reliable and least problematic method. This approach ensures maximum compatibility and reduces the likelihood of encountering runtime issues. However, it is also the less practical option, as it requires the use of the terminal for the execution.
+
+## Requirements
+* Python (3.11 or higher)
+
+## Procedure
+
+1. Download and install Python (3.11 or higher) from the official [website](https://www.python.org/downloads/). Be sure to select the flag `Add Python 3.x to PATH` during the first part of the installation.
+
+2. Download Artemis source code from the [latest release](https://github.com/AresValley/Artemis/releases) in the GitHub repository.
+
+3. Extract the downloaded archive.
+
+4. Open the terminal in Artemis folder and install the required Python libraries with PIP:
+    ```
+    pip install -r requirements.txt --user
+    ```
+
+5. Launch Artemis:
+    ```
+    python app.py
+    ```
+
+!!! example "Note for Developers"
+    Whenever modifications are made to any **.qml** file or any assets (such as images, icons, etc.), it is essential to recompile the **resource.py** file to ensure that the changes are reflected in the application. To achieve this, execute the following command:
+    ```
+    pyside6-rcc ./artemis.qrc -o artemis/resources.py
+    ```
+
+## Folders Structure
+Artemis can be safely executed and/or installed in any folder (even protected ones, such as `Program Files (x86)` in Windows) because Artemis performs read-only operations in the `BASE_DIR` folder from where it runs. All the reading-writing operations (such as database ops, logging, etc.) are performed in standard folders as follow:
+
+### :simple-windows: Windows
+* Data, Cache, Configurations: `$USER\AppData\Local\AresValley\Artemis`
+* Logs: `$USER\AppData\Local\Temp`
+
+### :simple-linux: Linux
+* Data, Cache, Configurations: `~/.local/share/AresValley/Artemis`
+* Logs: `/tmp`
+
+### :simple-apple: Mac OS
+* Data, Cache, Configurations: `~/Library/Application Support/AresValley/Artemis`
+* Logs: `/tmp`
--- a/docs/space_weather/SSA.md
+++ b/docs/space_weather/SSA.md
@@ -0,0 +1,37 @@
+# Solar Synoptic Analysis
+Synoptic maps of the solar surface are drawn each day by SWPC forecasters, providing forecasters with a broad outline of solar surface features. These maps were started on June 2, 1972 and have been produced daily since then.
+
+![hmib](../assets/ssa_1.webp)
+
+!!! quote "Source"
+    The Solar Synoptic Analysis is courtesy of the Space Weather Prediction Center (SWPC) part of the National Oceanic and Atmospheric Administration (NOAA), located in Boulder, Colorado.
+
+## How to Read
+
+### Active Regions
+Active regions are localized magnetic fields on the Sun. Areas with strong or intense magnetic fields provide energy for solar flares and coronal mass ejections (CMEs), so accurate forecasting of space weather activity requires an accurate picture of these regions.
+**Active regions are given official numbers by SWPC, and the drawings include the probabilities of C, M, and X class flares for the next 24 hours associated with each active region, along with a proton event probability.**
+
+### Coronal Holes
+Coronal holes are single polarity magnetic regions that are the source of high speed solar winds which drive magnetospheric activity. Coronal holes are the most common cause of geomagnetic storms. Coronal holes have historically been identified from He I 10830A ground-based observations. **The boundaries of coronal holes are shown on the synoptic drawings as lines with hash marks on the coronal hole side of the boundary line.**
+
+### Neutral Lines
+Large magnetic field structures of one magnetic polarity have a ‘neutral line’ at the boundary of the different magnetic polarities of the fields. Neutral lines are associated with flaring in active regions, and filaments/prominences are often associated with the neutral lines on a quiet sun. **Neutral lines appear as dashed lines on the synoptic drawings and the forecaster indicates the polarity of the magnetic field on either side of the neutral line with + (positive) and – (negative) signs.**
+
+### Plages
+Plages make up most of an Active Region, and appear bright in conjunction with the dark sunspots. Plages have strong magnetic fields but disorganized magnetic fields, unlike the highly organized fields of sunspots. **In the synoptic drawings, plages are colored red.** It is quite normal to have regions of plage with no sunspots, which do not receive an official number since they are not considered active regions and are unlikely to produce solar flares.
+
+### Filaments and Prominences
+Highly-stable regions of high density gas in the low density corona are called filaments. When these occur near the limb and can be seen protruding from the corona, often in spectacular fashion, they are called prominences. When they erupt they can be a geomagnetic storm threat, but the eruptions are usually slow and don’t often drive large storms. **The filaments and prominences are drawn as outlines with hash marks.**
+
+## Solar Coordinates
+- Lt: The current Carrington longitude line (north to south) at solar center disk.
+- Bt: Referred to as the B-angle. The angle measured from the current position of Earth within its tilted (inclined) orbit, compared to the Sun’s equator. It ranges between + or – 7.23 degrees.
+- Pt: Referred to as the position angle. Essentially, the current angle between Earth’s geocentric north pole and the Sun’s rotational north pole. The range is between + or – 26.31 degrees.
+- Returning Carringtons: Refers to the next 3 days of returning Carrington longitude lines to the east limb of the Sun.
+
+## Spot Group Labeling
+Spot groups are labeled with their assigned NOAA SWPC number. Underneath that number are four probability numbers (from 1 to 100 %) for C-class flares, M-class flares, X-class flares, and energetic proton events.
+
+## Coronal Hole Labeling
+Coronal holes are labeled with their assigned number. Underneath that number is a plus or minus sign representing the polarity of the coronal hole. Beside that figure is a number from 1 to 4 representing confidence of coronal hole analysis (4=good; 3=fair; 2=poor; 1=uncertain).
--- a/docs/space_weather/aurora.md
+++ b/docs/space_weather/aurora.md
@@ -0,0 +1,9 @@
+#
+
+![sw_current](../assets/sw_4.webp)
+
+This short-term aurora forecast predicts its location and intensity over the next 30 to 90 minutes, based on the [OVATION model](https://www.swpc.noaa.gov/products/aurora-30-minute-forecast). The lead time of the forecast corresponds to the duration it takes for the solar wind to travel from the L1 observation point to Earth.
+
+Auroras indicate current geomagnetic storm conditions and provide situational awareness for various technologies: for example, they directly affect HF radio communication and GPS/GNSS satellite navigation and are related to ground-induced currents impacting electric power transmission.
+
+For many people, the aurora is a beautiful nighttime phenomenon that is worth traveling to arctic regions just to observe.  It is the only way for most people to actually experience space weather.
--- a/docs/space_weather/current.md
+++ b/docs/space_weather/current.md
@@ -0,0 +1,225 @@
+#
+
+![sw_current](../assets/sw_1.webp)
+
+## 1. Kp Index
+The **K index** is a number (from 0 to 9) that shows how much Earth's magnetic field is disturbed. A K index of 1 means things are calm, while a K index of 5 or higher indicates a geomagnetic storm. These disturbances are measured with magnetometers that track changes in Earth's magnetic field every three hours. The K itself comes from a German word "Kennziffer" meaning "characteristic digit". To get a big picture of what's happening around the world, an official planetary **Kp index** is calculated. This is done by averaging the K indices from a special network of 13 geomagnetic observatories located around the globe at mid-latitudes.
+
+|Index|Activity Level|High Latitudes|Low Latitudes|Possible Source|
+|-|-|-|-|-|
+|**Kp 0**|Inactive|Weak & slow aurora possible|Aurora extremely unlikely|Small influx of particles due to some reconnections mostly at the magnetotail|
+|**Kp 1**|Very Quiet|Weak & slow aurora likely|Aurora very unlikely|Vide supra|
+|**Kp 2**|Quiet|Moderate auroral display|Aurora unlikely|Vide supra|
+|**Kp 3**|Unsettled|Active auroral display, sporadic substorm possible|Weak aurora display possible|Coronal hole sending fast winds or remains after days of storming, enhanced solar wind|
+|**Kp 4**|Active|Active auroral display, multiple sporadic substorms possible|Weak Aurora Display Possible|Vide supra|
+|**Kp 5**|Minor Storm (G1)|Very active auroral display, multiple substorms likely|Aurora display likely|Coronal hole sending fast winds or coronal mass ejection (CME), enhanced solar wind|
+|**Kp 6**|Moderate Storm (G2)|Strong auroral display, longer substorms|Active auroral display very likely|Vide supra|
+|**Kp 7**|Strong Storm (G3)|Very strong auroral display|Strong auroral display extremely likely|Large CMEs caused by solar storms or flares, very enhanced solar wind with strong shock wave|
+|**Kp 8**|Severe Storm (G4)|Extremely strong aurora, long periods of substorming|Strong auroral display extremely likely|Vide supra|
+|**Kp 9**|Extreme Storm (G5)|Extremely strong aurora, long periods of substorming|Very strong auroral display, overhead aurora possible|Super CMEs, Carrington-class events, devastating solar wind with extreme shock waves|
+
+## 2. Ap Index
+The **A index** represents the three-hourly equivalent amplitude of geomagnetic activity at a specific magnetometer station, derived from the station-specific K index. Due to the quasi-logarithmic nature of the K-scale in relation to magnetometer fluctuations, directly averaging a set of K indices is not really meaningful. Instead each K is converted back into a linear scale. The **Ap index** is determined by averaging the eight daily Ap values (3-hour) and using the same stations grid explained for the Kp index in the previous section. This provides a measure of geomagnetic activity for a specific day. Days with higher levels of geomagnetic activity correspond to higher daily Ap values.
+
+## 3. NOAA Space Weather Scale
+
+### Geomagnetic Storm
+
+??? danger "G5 (Extreme)"
+    * **Physical measure:** Kp = 9
+    * **Average Frequency:** 4 days per cycle (11 years)
+
+    **Power systems:** Widespread voltage control problems and protective system problems can occur, some grid systems may experience complete collapse or blackouts. Transformers may experience damage.
+
+    **Spacecraft operations:** May experience extensive surface charging, problems with orientation, uplink/downlink and tracking satellites.
+
+    **Other systems:** Pipeline currents can reach hundreds of amps, HF (high frequency) radio propagation may be impossible in many areas for one to two days, satellite navigation may be degraded for days, low-frequency radio navigation can be out for hours, and aurora has been seen as low as Florida and southern Texas (typically 40° geomagnetic lat.).
+
+??? danger "G4 (Severe)"
+    * **Physical measure:** Kp = 8 to 9-
+    * **Average Frequency:** 60 days per cycle (11 years)
+
+    **Power systems:** Possible widespread voltage control problems and some protective systems will mistakenly trip out key assets from the grid.
+
+    **Spacecraft operations:** May experience surface charging and tracking problems, corrections may be needed for orientation problems.
+
+    **Other systems:** Induced pipeline currents affect preventive measures, HF radio propagation sporadic, satellite navigation degraded for hours, low-frequency radio navigation disrupted, and aurora has been seen as low as Alabama and northern California (typically 45° geomagnetic lat.).
+
+??? warning "G3 (Strong)"
+    * **Physical measure:** Kp = 7
+    * **Average Frequency:** 130 days per cycle (11 years)
+
+    **Power systems:** Voltage corrections may be required, false alarms triggered on some protection devices.
+
+    **Spacecraft operations:** Surface charging may occur on satellite components, drag may increase on low-Earth-orbit satellites, and corrections may be needed for orientation problems.
+
+    **Other systems:** Intermittent satellite navigation and low-frequency radio navigation problems may occur, HF radio may be intermittent, and aurora has been seen as low as Illinois and Oregon (typically 50° geomagnetic lat.).
+
+??? warning "G2 (Moderate)"
+    * **Physical measure:** Kp = 6
+    * **Average Frequency:** 360 days per cycle (11 years)
+
+    **Power systems:** High-latitude power systems may experience voltage alarms, long-duration storms may cause transformer damage.
+
+    **Spacecraft operations:** Corrective actions to orientation may be required by ground control; possible changes in drag affect orbit predictions.
+
+    **Other systems:** HF radio propagation can fade at higher latitudes, and aurora has been seen as low as New York and Idaho (typically 55° geomagnetic lat.).
+
+??? info "G1 (Minor)"
+    * **Physical measure:** Kp = 5
+    * **Average Frequency:** 900 days per cycle (11 years)
+
+    **Power systems:** Weak power grid fluctuations can occur.
+
+    **Spacecraft operations:** Minor impact on satellite operations possible.
+
+    **Other systems:** Migratory animals are affected at this and higher levels; aurora is commonly visible at high latitudes (northern Michigan and Maine).
+
+### Solar Radiation Storms
+
+??? danger "S5 (Extreme)"
+    * **Physical measure:** Flux level of $\ge 10 MeV$ particles = $10^5$
+    * **Average Frequency:** < 1 event per cycle (11 years)
+
+    **Biological:** Unavoidable high radiation hazard to astronauts on EVA (extra-vehicular activity); passengers and crew in high-flying aircraft at high latitudes may be exposed to radiation risk.
+
+    **Satellite operations:** Satellites may be rendered useless, memory impacts can cause loss of control, may cause serious noise in image data, star-trackers may be unable to locate sources; permanent damage to solar panels possible.
+
+    **Other systems:** Complete blackout of HF (high frequency) communications possible through the polar regions, and position errors make navigation operations extremely difficult.
+
+??? danger "S4 (Severe)"
+    * **Physical measure:** Flux level of $\ge 10 MeV$ particles = $10^4$
+    * **Average Frequency:** 3 events per cycle (11 years)
+
+    **Biological:** Unavoidable radiation hazard to astronauts on EVA; passengers and crew in high-flying aircraft at high latitudes may be exposed to radiation risk.
+
+    **Satellite operations:** May experience memory device problems and noise on imaging systems; star-tracker problems may cause orientation problems, and solar panel efficiency can be degraded.
+
+    **Other systems:** Blackout of HF radio communications through the polar regions and increased navigation errors over several days are likely.
+
+??? warning "S3 (Strong)"
+    * **Physical measure:** Flux level of $\ge 10 MeV$ particles = $10^3$
+    * **Average Frequency:** 10 events per cycle (11 years)
+
+    **Biological:** Radiation hazard avoidance recommended for astronauts on EVA; passengers and crew in high-flying aircraft at high latitudes may be exposed to radiation risk.
+
+    **Satellite operations:** Single-event upsets, noise in imaging systems, and slight reduction of efficiency in solar panel are likely.
+
+    **Other systems:** Degraded HF radio propagation through the polar regions and navigation position errors likely.
+
+??? warning "S2 (Moderate)"
+    * **Physical measure:** Flux level of $\ge 10 MeV$ particles = $10^2$
+    * **Average Frequency:** 25 events per cycle (11 years)
+
+    **Biological:** Passengers and crew in high-flying aircraft at high latitudes may be exposed to elevated radiation risk.
+
+    **Satellite operations:** Infrequent single-event upsets possible.
+
+    **Other systems:** Small effects on HF propagation through the polar regions and navigation at polar cap locations possibly affected.
+
+??? info "S1 (Minor)"
+    * **Physical measure:** Flux level of $\ge 10 MeV$ particles = $10$
+    * **Average Frequency:** 50 events per cycle (11 years)
+
+    **Biological:** None.
+
+    **Satellite operations:** None.
+
+    **Other systems:** Minor impacts on HF radio in the polar regions.
+
+### Radio Blackouts
+
+??? danger "R5 (Extreme)"
+    * **Physical measure:*** X20 ($2e^{-3} Wm^{-2}$)
+    * **Average Frequency:** < 1 days per cycle (11 years)
+
+    **HF Radio:** Complete HF (high frequency**) radio blackout on the entire sunlit side of the Earth lasting for a
+    number of hours. This results in no HF radio contact with mariners and en route aviators in this sector.
+
+    **Navigation:** Low-frequency navigation signals used by maritime and general aviation systems experience outages
+    on the sunlit side of the Earth for many hours, causing loss in positioning. Increased satellite navigation errors in
+    positioning for several hours on the sunlit side of Earth, which may spread into the night side. 
+
+    *GOES X-ray peak brightness by class and by flux (measured in the 0.1-0.8 nm range, in W·m-2)
+
+??? danger "R4 (Severe)"
+    * **Physical measure:*** X10 ($10^{-3} Wm^{-2}$)
+    * **Average Frequency:** 8 days per cycle (11 years)
+
+    **HF Radio:** HF radio communication blackout on most of the sunlit side of Earth for one to two hours. HF radio
+    contact lost during this time.
+
+    **Navigation:** Outages of low-frequency navigation signals cause increased error in positioning for one to two
+    hours. Minor disruptions of satellite navigation possible on the sunlit side of Earth.
+
+    *GOES X-ray peak brightness by class and by flux (measured in the 0.1-0.8 nm range, in W·m-2)
+
+??? warning "R3 (Strong)"
+    * **Physical measure:*** X1 ($10^{-4} Wm^{-2}$)
+    * **Average Frequency:** 140 days per cycle (11 years)
+
+    **HF Radio:** Wide area blackout of HF radio communication, loss of radio contact for about an hour on sunlit side
+    of Earth.
+
+    **Navigation:** Low-frequency navigation signals degraded for about an hour. 
+
+    *GOES X-ray peak brightness by class and by flux (measured in the 0.1-0.8 nm range, in W·m-2)
+
+??? warning "R2 (Moderate)"
+    * **Physical measure:*** M5 ($5e^{-5} Wm^{-2}$)
+    * **Average Frequency:** 300 days per cycle (11 years)
+
+    **HF Radio:** Limited blackout of HF radio communication on sunlit side of the Earth, loss of radio contact for tens
+    of minutes.
+
+    **Navigation:** Degradation of low-frequency navigation signals for tens of minutes. 
+
+    *GOES X-ray peak brightness by class and by flux (measured in the 0.1-0.8 nm range, in W·m-2)
+
+??? info "R1 (Minor)"
+    * **Physical measure:*** M1 ($10^{-5} Wm^{-2}$)
+    * **Average Frequency:** 950 days per cycle (11 years)
+
+    **HF Radio:** Weak or minor degradation of HF radio communication on sunlit side of the Earth, occasional loss of
+    radio contact.
+
+    **Navigation:** Low-frequency navigation signals degraded for brief intervals. 
+
+    *GOES X-ray peak brightness by class and by flux (measured in the 0.1-0.8 nm range, in W·m-2)
+
+## 4. X-Ray Solar Activity
+This is a summary of the **X-Ray Flare Class**. Large solar X-ray flares can change the Earth’s ionosphere, which blocks high-frequency (HF) radio transmissions on the sunlit side of the Earth. Solar flares are also associated with Coronal Mass Ejections (CMEs) which can ultimately lead to geomagnetic storms. SWPC sends out space weather alerts at the M5 level. Some large flares are accompanied by strong radio bursts that may interfere with other radio frequencies and cause problems for satellite communication and radio navigation (GPS).
+
+| Class | Peak Strength (W/m<sup>2</sup>) | Effects on Earth                                             |
+|-------|---------------------------------|--------------------------------------------------------------|
+| B     | I < 10<sup>-6</sup>             | Too small to harm Earth                                      |
+| C     | 10<sup>-6</sup> ≤ I < 10<sup>-5</sup> | Small with few noticeable consequences                 |
+| M     | 10<sup>-5</sup> ≤ I < 10<sup>-4</sup> | Brief radio blackouts in polar regions, minor radiation storms |
+| X     | I ≥ 10<sup>-4</sup>             | Planet-wide radio blackouts, long-lasting radiation storms |
+
+## 5. RF Propagation
+
+### Maximum Usable Frequency
+In radio transmission, the maximum usable frequency (MUF) is the highest frequency that can be effectively used for communication between two locations on Earth by reflecting off the ionosphere (via skywave or skip) at a given time, regardless of the transmitter's power. This measurement is particularly valuable for shortwave transmissions.
+
+### Earth-Moon-Earth
+Earth–Moon–Earth communication (EME), commonly referred to as Moon bounce, is a radio communication method in which radio waves are transmitted from an Earth-based station, reflected off the Moon's surface, and then received back on Earth. The value gives the probability of a succesfull connection.
+
+### Meteor Scatter
+Meteor burst communications (MBC), also known as meteor scatter (MS) communications, is a radio propagation technique that uses the ionized trails created by meteors entering the atmosphere to establish brief communication links between radio stations up to 2,250 kilometers (1,400 miles) apart. This can involve either forward-scatter or back-scatter of the radio waves. Like EME, the value gives the probability of a succesfull connection.
+
+### Sporadic-E
+**Report of the latest E-skip spots on 50, 70 & 144 MHz by [DXrobot](https://dxrobot.gooddx.net/)**
+
+Sporadic E (Es or SpE) is a rare type of radio propagation that uses a lower part of the Earth's ionosphere, which typically doesn't refract radio waves. It reflects signals off small "clouds" in the E region at altitudes of 95-150 km (50-100 miles). Unlike the regular F region skywave propagation, which depends on daily cycles of ionized layers from UV light, Sporadic E uses transient ionized patches. This allows for occasional long-distance VHF communication, usually during the six weeks around the summer solstice, beyond the normal line-of-sight range.
+
+### Aurora Spots
+**Report of the latest aurora spots on 50, 70 & 144 MHz by [DXrobot](https://dxrobot.gooddx.net/)**
+
+Auroral propagation, or auroral backscatter, is a form of radio propagation that occurs during an auroral event, affecting VHF and UHF communications. Increased ionization in the E layer of the ionosphere reflects signals at much higher frequencies than usual, enabling communication up to 1000 MHz, though 500 MHz is more common. Signals are directed towards the auroral region and reflected back, but they are often distorted due to particle movement (the signal is roughly Doppler shifted of 1 kHz at around 150 MHz as the electrons stream down).
+
+### Expected HF Noise
+This is just the expected noise in HF based on the current Space Weather conditions.
+
+## 6. Report Age
+Poseidon Daemon is in charge of parse all the necessary data used for the Space Weather module. The data of the last generated report is written here.
--- a/docs/space_weather/drap.md
+++ b/docs/space_weather/drap.md
@@ -0,0 +1,7 @@
+#
+
+![sw_current](../assets/sw_3.webp)
+
+The D-Region Absorption Product (DRAP) evaluates the effects of solar X-ray flux and solar energetic particle (SEP) events on HF radio communication. Long-distance communications using high frequency (HF) radio waves (3 - 30 MHz) rely on signal reflection in the ionosphere. Typically, radio waves reflect near the peak of the F2 layer (~300 km altitude), but during their journey to and from this peak, the signals experience attenuation due to absorption by the intervening ionosphere.
+
+The [D-Region Absorption Prediction model](https://www.swpc.noaa.gov/products/d-region-absorption-predictions-d-rap) provides guidance to understand the degradation and blackouts of HF radio communications that can result from these conditions.
--- a/docs/space_weather/forecasts.md
+++ b/docs/space_weather/forecasts.md
@@ -0,0 +1,15 @@
+#
+
+![sw_current](../assets/sw_2.webp)
+
+## 1. Forecast Summary
+Geomagnetic activity, Solar Radiation Storms and Radio Blackouts probable events (in the next 3 days) are described in this section. 
+
+## 2. 3-Day Kp Index
+This is a 3 day projection of the [Kp index](current.md).
+
+## 3. Events Probability
+The probability (in percentage) of different events that can take place and generate some important conditions for RF propagation. All the event are explained [here](current.md).
+
+!!! info
+    Geomagnetic Activity has two percentual value per day: the left one refers to high-latitude location and the right one is for middle-latitude locations.
--- a/docs/space_weather/imagers.md
+++ b/docs/space_weather/imagers.md
@@ -0,0 +1,114 @@
+# Sun Imagers
+
+## Atmospheric Imagery Assembly
+### 94 Å
+![aia_0094](../assets/aia_0094.webp)
+
+This channel (as well as AIA 131) is designed to study solar flares. It measures extremely hot temperatures around 6 million Kelvin (10.8 million F). It can take images every 2 seconds (instead of 10) in a reduced field of view in order to look at flares in more detail.
+
+- **Where:** Flaring regions of the corona
+- **Wavelength:** 94 angstroms (0.0000000094 m) = Extreme Ultraviolet/soft X-rays
+- **Primary ions seen:** 17 times ionized iron (Fe XVIII)
+- **Characteristic temperature:** 6 million K (10.8 million F)
+
+### 131 Å
+![aia_0131](../assets/aia_0131.webp)
+
+This channel (as well as AIA 094) is designed to study solar flares. It measures extremely hot temperatures around 10 million K (18 million F), as well as cool plasmas around 400,000 K (720,000 F). It can take images every 2 seconds (instead of 10) in a reduced field of view in order to look at flares in more detail.
+
+- **Where:** Flaring regions of the corona
+- **Wavelength:** 131 angstroms (0.0000000131 m) = Extreme Ultraviolet
+- **Primary ions seen:** 20 and 7 times ionized iron (Fe VIII, Fe XXI)
+- **Characteristic temperatures:** 10 million K (18 million F)
+
+### 171 Å
+![aia_0171](../assets/aia_0171.webp)
+
+This channel is especially good at showing coronal loops - the arcs extending off of the Sun where plasma moves along magnetic field lines. The brightest spots seen here are locations where the magnetic field near the surface is exceptionally strong.
+
+- **Where:** Quiet corona and upper transition region
+- **Wavelength:** 171 angstroms (0.0000000171 m) = Extreme Ultraviolet
+- **Primary ions seen:** 8 times ionized iron (Fe IX)
+- **Characteristic temperature:** 1 million K (1.8 million F)
+
+### 193 Å
+![aia_0193](../assets/aia_0193.webp)
+
+This channel highlights the outer atmosphere of the Sun - called the corona - as well as hot flare plasma. Hot active regions, solar flares, and coronal mass ejections will appear bright here. The dark areas - called coronal holes - are places where very little radiation is emitted, yet are the main source of solar wind particles.
+
+- **Where:** Corona and hot flare plasma
+- **Wavelength:** 193 angstroms (0.0000000193 m) = Extreme Ultraviolet
+- **Primary ions seen:** 11 times ionized iron (Fe XII)
+- **Characteristic temperature:** 1.25 million K (2.25 million F)
+
+### 304 Å
+![aia_0304](../assets/aia_0304.webp)
+
+This channel is especially good at showing areas where cooler dense plumes of plasma (filaments and prominences) are located above the visible surface of the Sun. Many of these features either can't be seen or appear as dark lines in the other channels. The bright areas show places where the plasma has a high density.
+
+- **Where:** Upper chromosphere and lower transition region
+- **Wavelength:** 304 angstroms (0.0000000304 m) = Extreme Ultraviolet
+- **Primary ions seen:** singly ionized helium (He II)
+- **Characteristic temperature:** 50,000 K (90,000 F)
+
+### 335 Å
+![aia_0335](../assets/aia_0335.webp)
+
+This channel (as well as AIA 211) highlights the active region of the outer atmosphere of the Sun - the corona. Active regions, solar flares, and coronal mass ejections will appear bright here. The dark areas - or coronal holes - are places where very little radiation is emitted, yet are the main source of solar wind particles.
+
+- **Where:** Active regions of the corona
+- **Wavelength:** 335 angstroms (0.0000000335 m) = Extreme Ultraviolet
+- **Primary ions seen:** 15 times ionized iron (Fe XVI)
+- **Characteristic temperature:** 2.8 million K (5 million F)
+
+### 1600 Å
+![aia_1600](../assets/aia_1600.webp)
+
+This channel (as well as AIA 1700) often shows a web-like pattern of bright areas that highlight places where bundles of magnetic fields lines are concentrated. However, small areas with a lot of field lines will appear black, usually near sunspots and active regions.
+
+- **Where:** Transition region and upper photosphere
+- **Wavelength:** 1600 angstroms (0.00000016 m) = Far Ultraviolet
+- **Primary ions seen:** thrice ionized carbon (C IV) and Continuum
+- **Characteristic temperatures:** 6,000 K (11,000 F), and 100,000 K (180,000 F)
+
+### 1700 Å
+![aia_1700](../assets/aia_1700.webp)
+
+This channel (as well as AIA 1600) often shows a web-like pattern of bright areas that highlight places where bundles of magnetic fields lines are concentrated. However, small areas with a lot of field lines will appear black, usually near sunspots and active regions.
+
+- **Where:** Temperature minimum and photosphere
+- **Wavelength:** 1700 angstroms (0.00000017 m) = Far Ultraviolet
+- **Primary ions seen:** Continuum
+- **Characteristic temperature:** 6,000 K (11,000 F)
+
+---
+## Helioseismic and Magnetic Imager
+### Magnetogram
+![hmib](../assets/HMIB.webp)
+
+Magnetograms show maps of the magnetic field on the Sun’s surface. The HMI instrument uses the Zeeman effect to measure the intensity of the magnetic field component along the line of sight by making use of the circularly polarized spectral line. The color chart of the magnetic field along the line of sight is designed to visually show both high and low values. Intensities less than 24G are shades of gray. Positive values of the field are green and blue. Negative values are yellow and red. Regions with a weak field appear mainly in yellow or green. Progressively positive values range from dark green to light green (at 236 G). Negative values range from light yellow to orange (at -236G). There is a strong discontinuity in the coloration at 236G. Positive or negative sunspots and other regions with an intense field appear blue or red with dark umbrae. There are 254 colors arranged symmetrically around 0. The 127 positive values include 2 grays tending toward dark, 13 greens toward light, and 110 blues toward dark. The 127 negative values include 2 grays tending toward light, 18 yellows toward dark, and 107 reds toward dark. Nominally, each color indicates a range of about 11.81 G, and the coloration altogether spans the range between -1500 G and 1500 G
+
+### Intensitygram
+![hmii](../assets/HMII.webp)
+
+HMI samples the Fe I absorption line at 6173.3 Å at six points, assuming that the "pure" profile of the Fe I line is Gaussian and the transmission profiles are delta functions, the first and second Fourier coefficients of the Fe I line profile can be calculated, and Doppler velocity estimation can be performed. An estimate of the intensity in the continuum is obtained by "reconstructing" the solar line from the Doppler offset and the thickness and depth of the line.
+
+### Dopplergram
+![hmid](../assets/HMID.webp)
+
+HMI camera 2 takes 72 images to construct a single Doppler diagram. Six images are taken at six positions across the spectral line at 6173.3 Å. Each image is taken in two polarization states, circularly polarized to the right (RCP or Stokes I-V) and circularly polarized to the left (LCP or Stokes I+V). Assuming that the absorption line is Gaussian and the transmission profiles of the HMI filter are delta functions, Fourier coefficients are calculated and then used to estimate the magnetic field B along the line of sight.
+
+---
+## Large Angle and Spectrometric Coronagraph
+### LASCO C1 (NOT AVAILABLE)
+A Fabry–Pérot interferometer coronagraph imaging from 1.1 to 3 solar radii, non-functional since the 24 June 1998 SOHO Mission Interruption
+
+### LASCO C2 (orange)
+![lasco_c2](../assets/lasco_c2.webp)
+
+A white light coronagraph imaging from 1.5 to 6 solar radii. The LASCO camera is equipped with an occulting disk that blocks out the Sun to be able to study the faint details in the corona.
+
+### LASCO C3 (blue)
+![lasco_c3](../assets/lasco_c3.webp)
+
+A white light coronagraph imaging from 3.7 to 30 solar radii
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Marco Dalla Tiezza	a87dd69a01	Rolling out DB v72	2025-05-04 21:55:43 +02:00
Marco Dalla Tiezza	79737c82cf	Docs updated	2024-10-25 00:15:29 +02:00
Marco Dalla Tiezza	2d773118fd	Rolling out v4.1.0	2024-10-20 20:38:41 +02:00
Marco Dalla Tiezza	7c6fc179a1	Merge pull request #62 from AresValley/develop Updated to 4.1.0	2024-10-20 20:00:33 +02:00
Marco Dalla Tiezza	2513f5d1e5	Updated resources and docs	2024-10-20 19:59:39 +02:00
Marco Dalla Tiezza	32a9ecddbf	Final bump to 4.1.0	2024-10-20 19:47:27 +02:00
Marco Dalla Tiezza	f2f5c1dc3d	Fixed Windows logo	2024-10-20 19:30:53 +02:00
Marco Dalla Tiezza	f67ee9bc92	Bumpt to python 3.12, updated action files and changelog	2024-10-20 19:22:25 +02:00
Marco Dalla Tiezza	7a696451f0	Updated dependencies and docs	2024-10-20 19:13:40 +02:00
Marco Dalla Tiezza	ff91da3c20	Rolling out DB v71	2024-10-11 01:26:56 +02:00
Marco Dalla Tiezza	53a7a1dda2	Update	2024-10-11 01:23:14 +02:00
Marco Dalla Tiezza	c229f51945	Rolling out DB v70	2024-08-31 15:14:21 +02:00
Marco Dalla Tiezza	2cbeec6af3	Added possibility to activate additionl printings aimed to debug for qt plugins	2024-06-27 12:34:01 +02:00
Marco Dalla Tiezza	463a532c27	Updated documentation for SSA and Sun Imagers	2024-06-27 12:20:58 +02:00
Marco Dalla Tiezza	a3bc1b0c59	Complete the UV imagers part with Atmospheric Imagery Assembly	2024-06-27 01:08:43 +02:00
Marco Dalla Tiezza	ccc6e99a7f	Added Synoptic Analysis, UV Imagers, and Spectrometric Coronagraph	2024-06-25 00:38:00 +02:00
Marco Dalla Tiezza	b8e6075aa0	Updated dependencies. Previous commit closes #4	2024-06-24 22:18:21 +02:00
Marco Dalla Tiezza	ddb952b894	Updated audio player with settings	2024-06-24 18:48:53 +02:00
Marco Dalla Tiezza	76bcbac60a	Updated readme.md	2024-06-22 18:37:44 +02:00
Marco Dalla Tiezza	319b11e77c	Rolling out DB v65	2024-06-22 15:17:22 +02:00
Marco Dalla Tiezza	5f513b1c76	Rolling out v4.0.5	2024-06-15 12:38:22 +02:00
Marco Dalla Tiezza	36648e08cc	Updated message on preference window, bump Artemis version to 4.0.5	2024-06-15 12:09:14 +02:00
Marco Dalla Tiezza	d61caa1ada	Removed unused imports, added date parser for db info data	2024-06-15 12:01:33 +02:00
Marco Dalla Tiezza	6fdd36b548	Code optimized: removed an additional db loading	2024-06-15 11:44:01 +02:00
Marco Dalla Tiezza	6213e8b1ca	Added creation date and version of the db on db manager window	2024-06-15 00:55:05 +02:00
Marco Dalla Tiezza	d0bfbe40d7	New logic for local sigid search	2024-06-15 00:40:00 +02:00
Marco Dalla Tiezza	ebda950c87	Updated docs	2024-06-14 21:33:42 +02:00
Marco Dalla Tiezza	c803a72489	Updated changelog and resources (after merge)	2024-06-14 01:18:48 +02:00
Marco Dalla Tiezza	70758ea8bd	Merge pull request #51 from AresValley/revised-networking Revised network manager, update manager and downloader	2024-06-13 23:08:42 +00:00
Marco Dalla Tiezza	6c0b1b7e04	Merge branch 'master' into revised-networking	2024-06-13 23:07:30 +00:00
Marco Dalla Tiezza	c17c1fdbea	Updated resources	2024-06-14 01:01:53 +02:00
Marco Dalla Tiezza	8138cf8e38	Docs update 2	2024-06-14 00:14:04 +02:00
Marco Dalla Tiezza	0b416f0a2e	Docs update	2024-06-13 23:55:41 +02:00
Marco Dalla Tiezza	1d0c459402	Fixed a potential issue where the downloader window closes but the downloader instance keeps running	2024-06-13 19:19:21 +02:00
Marco Dalla Tiezza	0f898ff6f5	Introduced temporary folder	2024-06-13 16:16:36 +02:00
Marco Dalla Tiezza	c58d85c6a2	Fixed bug of space_weather introduced with the new update_manager	2024-06-13 15:52:47 +02:00
Marco Dalla Tiezza	f73034c35c	Preparatory update for the new update manager	2024-06-13 15:46:56 +02:00
Marco Dalla Tiezza	77c43813a0	Final ieration of the new downloader and update_manager, implemented automatic updates only for windows	2024-06-13 15:46:25 +02:00
Marco Dalla Tiezza	b01bd99ecf	Preparatory update for the new update manager	2024-06-13 14:57:36 +02:00
Marco Dalla Tiezza	146a5d1605	First implementation of the auto update for windows	2024-06-13 14:40:07 +02:00
Marco Dalla Tiezza	ea245c853b	Updated changelog and documentation	2024-06-13 12:20:12 +02:00
Marco Dalla Tiezza	e57e9bf8e4	Artemis can be fully navigated (and so the signal list) just with the keyboard, fixed #50	2024-06-13 11:42:24 +02:00
Marco Dalla Tiezza	70ed158b02	Updated resources, fixed typo	2024-06-13 02:06:45 +02:00
Marco Dalla Tiezza	1d795b688e	File size request from HTTP header, handled the indeterminate size case	2024-06-13 01:54:59 +02:00
Marco Dalla Tiezza	52c4fbcce9	Downloader has been generalized, now network_utils is update_utils	2024-06-13 01:05:53 +02:00
Marco Dalla Tiezza	79891899ce	Improved label readability, handled non critical exception about filtering without a loaded DB	2024-06-12 23:16:48 +02:00
Marco Dalla Tiezza	dde223d2ac	Updated documentation	2024-06-12 21:20:18 +02:00
Marco Dalla Tiezza	43ddee410a	Removed unnecessay arguments (now default) for nuitka	2024-06-11 18:37:50 +02:00
Marco Dalla Tiezza	ecbf10ebb5	Rolling out v4.0.3	2024-06-10 22:20:37 +02:00
Marco Dalla Tiezza	5d3cdb7abb	Updated to v4.0.3 (hotfix)	2024-06-10 21:57:47 +02:00
Marco Dalla Tiezza	5b8670814b	Removed setProperty and findChild in dowloader.py for code uniformity	2024-06-10 21:51:53 +02:00
Marco Dalla Tiezza	19acf11b1a	Fixed a potential bug affecting ARM architecture	2024-06-10 21:30:28 +02:00
Marco Dalla Tiezza	39056d1d91	Updated name of excluded DLLs (only for linux since it is using a lib prefix)	2024-06-10 21:22:32 +02:00
Marco Dalla Tiezza	436c54b733	Fixed #48 an error occurig on Linux where configuration file path are not properly resolved during startup with the binary version of the program	2024-06-10 20:40:46 +02:00
Marco Dalla Tiezza	b48a42dcc8	Explicit DLLs inclusion/exclusion in Nuitka, close #47	2024-06-10 16:55:04 +02:00
Marco Dalla Tiezza	e00e21c46a	Fixed #46	2024-06-10 11:56:27 +02:00
Marco Dalla Tiezza	2aa821ee65	Minor docs fix	2024-06-09 16:42:19 +02:00
Marco Dalla Tiezza	5ab0c39aa9	Rolling out v4.0.1	2024-06-09 16:31:21 +02:00
Marco Dalla Tiezza	f09bbd3311	Revert "Bump Nuitka 2.3.1" This reverts commit `91589018a3`.	2024-06-09 16:07:24 +02:00
Marco Dalla Tiezza	91589018a3	Bump Nuitka 2.3.1	2024-06-09 15:42:40 +02:00
Marco Dalla Tiezza	d41c9e1ed6	Added installer icon, bump version 4.0.1	2024-06-09 15:36:54 +02:00
Marco Dalla Tiezza	0cbd9a7a0b	Updated documentation	2024-06-09 15:17:13 +02:00
Marco Dalla Tiezza	7db68ab2ad	Integrity check for the configuration parser	2024-06-06 22:34:51 +02:00
Marco Dalla Tiezza	c7c53b5a68	Solved clipping of the scrollbar on different textareas	2024-06-06 20:12:29 +02:00
Marco Dalla Tiezza	9d2443b0f0	Updated docs	2024-06-06 19:20:03 +02:00
Marco Dalla Tiezza	2c3ffd5e66	Updated readme image	2024-06-06 19:15:46 +02:00
Marco Dalla Tiezza	485eccb373	Added DB autoload on startup option	2024-06-06 19:06:45 +02:00
Marco Dalla Tiezza	faf9a5293a	Normalized K and A index lights to NOAA standard nomnclature	2024-06-06 18:11:15 +02:00
Marco Dalla Tiezza	e58cf4d206	Updated docs	2024-06-06 15:51:20 +02:00
Marco Dalla Tiezza	1b48405c14	Rolling out DB v61	2024-06-05 22:20:43 +02:00
Marco Dalla Tiezza	c8fcb2c3e0	Added project webpage in help section	2024-06-05 21:03:06 +02:00
Marco Dalla Tiezza	ab8403c16e	Corrected few docs typo	2024-06-05 00:05:00 +02:00
Marco Dalla Tiezza	7929c23ac5	Fixed a bug introduced in `10607c88ea`	2024-06-04 22:15:44 +02:00
Marco Dalla Tiezza	707cc001cf	Updated docs about new text search behaviour	2024-06-04 21:57:56 +02:00
Marco Dalla Tiezza	4594237c09	Added volume slider and mute bbutton to audio player, closed #45	2024-06-04 21:43:57 +02:00
Marco Dalla Tiezza	10607c88ea	Searches in the name field has been extended to the description as well (close #44 )	2024-06-04 19:51:21 +02:00
Marco Dalla Tiezza	f61527ed70	Locked audio player upon signal deletion	2024-06-04 19:30:15 +02:00
Marco Dalla Tiezza	4e7ebcc2f5	Read-only ops are separated in different standard and OS dependent folders from read-write ones (fixed #43 ), bump Nuitka 2.3	2024-06-04 19:25:12 +02:00
Marco Dalla Tiezza	16e2668fe9	Forced std error and std output in building script for Windows for logging purposes	2024-06-02 00:57:32 +02:00
Marco Dalla Tiezza	cc607fdd28	Added more extension for FileDialog	2024-06-01 22:28:13 +02:00
Marco Dalla Tiezza	f5565a6b5e	Basic Operations chapter added to the docs	2024-06-01 22:22:14 +02:00
Marco Dalla Tiezza	04bc4cce5f	Added documentation for the new 2 products implemented in the previous commits	2024-06-01 13:12:15 +02:00
Marco Dalla Tiezza	c6afcc0e75	Added Aurora Forecast Model	2024-06-01 11:48:27 +02:00
Marco Dalla Tiezza	3fdbdbfae4	Added D-Region Absorption Predictions	2024-05-31 19:59:51 +02:00
Marco Dalla Tiezza	359e5c9076	Added Sporadic-E and Aurora spots in RF propagation panel	2024-05-31 16:48:27 +02:00
Marco Dalla Tiezza	7a89b64ca8	Code polished from unused functions	2024-05-31 16:36:34 +02:00
Marco Dalla Tiezza	e2a48e7a54	Docs updated and corrected a type in the space weather window	2024-05-30 18:25:18 +02:00
Marco Dalla Tiezza	2a70e42a59	Changed to GitHub hosted latest software and db version manifest	2024-05-30 12:48:29 +02:00
Marco Dalla Tiezza	f0db05c96e	Fixed typo in .iss file	2024-05-28 22:56:46 +02:00
Marco Dalla Tiezza	528c816508	Artemis 4 RC1	2024-05-28 22:40:45 +02:00
AresValley	acc44c93b3	Changed default theme	2023-04-18 19:43:39 +02:00
AresValley	0a5fefa214	Production .yml for windows OS	2023-04-18 19:42:36 +02:00
AresValley	c658e072f7	Small correction	2023-04-16 18:12:30 +02:00
AresValley	81f9e958d6	Action updated to incorporate icon on macOS devices	2023-04-16 18:08:38 +02:00
AresValley	b41ad0e8f2	Updated Nuitka-windows.yml	2022-12-13 21:32:47 +01:00
AresValley	ed8be2d274	Uptade Nuitka yml for windows	2022-10-04 13:53:48 +02:00
AresValley	1cbf01f307	Nuitka compatibility for cacert.pem path	2022-10-04 13:35:42 +02:00
AresValley	93a946e2a9	Fixed macOS yml	2022-10-04 01:48:54 +02:00
AresValley	fef8b71c46	Extended IS_BINARY func: added Nuitka compatibility	2022-10-04 01:39:40 +02:00
AresValley	adf7421c94	Added macOS Nuitka action	2022-10-04 01:37:26 +02:00
AresValley	047d5c8ffd	Update Linux Nuitka action	2022-10-03 23:18:21 +02:00
AresValley	b6d7f39efc	Updater included during compiling with Nuitka	2022-10-03 17:55:11 +02:00
AresValley	cc0efafc92	Updated .ymls, created nuitka .yml	2022-10-03 15:49:25 +02:00
Marco Dalla Tiezza	6ace19d75c	Merge pull request #35 from AresValley/Linux-and-MacOS-autopack Linux, MacOS packaging actions and updated readme	2022-10-01 19:45:27 +02:00
AresValley	d2e0ece9eb	Linux and MacOS autopack actions	2022-10-01 19:40:06 +02:00
AresValley	d1716621b0	Auto packaging script for Linux OS	2022-10-01 12:30:32 +02:00
AresValley	cd5d31b404	Updated changelog	2022-09-30 22:37:22 +02:00
AresValley	5a1db2c0d4	Updated version info	2022-09-30 22:33:25 +02:00
AresValley	e4fdf1d564	Changed python version (3.10->3.9) for packaging	2022-09-30 22:10:12 +02:00
AresValley	3e02dd7bfa	Updated changelog and version	2022-09-29 18:12:56 +02:00
AresValley	0e20fcbc71	Auto packaging for windows with GitHub actions	2022-09-29 18:02:38 +02:00
Marco Dalla Tiezza	91099940ff	Merge pull request #34 from pinkavaj/pi-fix-play Fix crash for playing audio	2022-09-29 17:58:29 +02:00
Jiří Pinkava	490d9cf3e6	Fix crash for playing audio pygame 2.1.2 (SDL 2.24.0, Python 3.10.7 File "audio_player.py", line 122, in _set_max_progress_bar self._audio_progress.setMaximum( TypeError: setMaximum(self, int): argument 1 has unexpected type 'float'	2022-09-27 23:39:24 +02:00
Marco Dalla Tiezza	c84b0d2963	Update README.md	2022-07-29 22:15:57 +02:00
				`@@ -0,0 +1 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="222.267" height="371.88" viewBox="0 0 166.7 278.91" fill="#231f20" xmlns:v="https://vecta.io/nano"><path d="M0 140.2L83.35 0l83.35 140.2-25.74 43.28-16.55-27.43c2.98-5.36 6.25-10.54 9.33-15.84L83.35 55.44 32.96 140.2l9.34 15.79-16.52 27.47L0 140.2zm37.52 62.49l45.83-76.19 45.83 76.18-45.83 76.23-45.83-76.22z"/></svg>`