peakviz 0.1.0__tar.gz

peakviz-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: peakviz
+Version: 0.1.0
+Summary: A tool to visualize Hyperspectral data from point and imaging sensors.
+Author-email: Tasnim Tabassum Nova <tabassumnova1@gmail.com>
+Project-URL: Homepage, https://github.com/TabassumNova/PeakViz
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyQt5
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: plotly
+Dynamic: license-file
+
+# PeakViz
+This repository represents a simple workflow to visualize Hyperspectral data from point sensors: PSR and Fourier Transform Infrared Spectroscopy (FTIR) sensor. The wavelength ranges for these sensors are :
+- PSR : 350.0 - 2500.0 nm
+- FTIR : 2500.0629 - 15385.6915 nm
+
+<p align="center">
+  <img src="image1.png" width="500"/>
+</p>
+
+# Tutorial
+Coming soon ...
+
+# Acknowledgement
+This work is performed at [Helmholtz Institute Freiberg for Resource Technology](https://www.hzdr.de/db/Cms?pOid=32948&pNid=2423&pLang=en) in the [Exploration](https://www.iexplo.space/) department
+
+
+

peakviz-0.1.0/README.md

@@ -0,0 +1,17 @@
+# PeakViz
+This repository represents a simple workflow to visualize Hyperspectral data from point sensors: PSR and Fourier Transform Infrared Spectroscopy (FTIR) sensor. The wavelength ranges for these sensors are :
+- PSR : 350.0 - 2500.0 nm
+- FTIR : 2500.0629 - 15385.6915 nm
+
+<p align="center">
+  <img src="image1.png" width="500"/>
+</p>
+
+# Tutorial
+Coming soon ...
+
+# Acknowledgement
+This work is performed at [Helmholtz Institute Freiberg for Resource Technology](https://www.hzdr.de/db/Cms?pOid=32948&pNid=2423&pLang=en) in the [Exploration](https://www.iexplo.space/) department
+
+
+

peakviz-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "peakviz"
+version = "0.1.0"
+description = "A tool to visualize Hyperspectral data from point and imaging sensors."
+authors = [
+    { name = "Tasnim Tabassum Nova", email = "tabassumnova1@gmail.com" }
+]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+dependencies = [
+    "PyQt5",
+    "numpy",
+    "matplotlib",
+    "pandas",
+    "plotly",
+]
+
+[project.urls]
+Homepage = "https://github.com/TabassumNova/PeakViz"

peakviz-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

peakviz-0.1.0/src/__init__.py

@@ -0,0 +1 @@
+from . import dataloader, point_sensor, pre_processing, vizualization

peakviz-0.1.0/src/dataloader.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import os
+import re
+
+def is_float(s):
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+def check_and_extract_line(file_path, search_text):
+    with open(file_path, 'r') as file:
+        content = file.read()
+    if search_text in content:
+        # Use regex to find the line starting with the specified 'line' variable
+        pattern = f"^{re.escape(search_text)}.*$"
+        match = re.search(pattern, content, re.MULTILINE)
+        if match:
+            return True, match.group(0)
+    return False, None
+
+def find_xy(extracted_line):
+    if re.search(r'reflectance', extracted_line, re.IGNORECASE):
+        return 'wavelength', 'reflectance'
+    elif re.search(r'absorbance', extracted_line, re.IGNORECASE):
+        wavenumber_present = bool(re.search(r'wavenumber', extracted_line, re.IGNORECASE))
+        wavelength_present = bool(re.search(r'nanometer', extracted_line, re.IGNORECASE))
+        if wavenumber_present:
+            return 'wavenumber', 'absorbance'
+        elif wavelength_present:
+            return 'wavelength', 'absorbance'
+
+
+# For point sensors
+# Load all type of files
+# Reflectance/ Absorbance/ Nanometer/ Wavenumber
+def load_data(paths, signal_type, search_text):
+    all_energy = []
+    ## for reference spectrum
+    spectrum_dict = {}
+    spectrum_dict['reflectance'] = []
+    spectrum_dict['absorbance'] = []
+    # if signal_type == 'reference':
+    #     refSpectrum_dict = {}
+    #     refSpectrum_dict['reflectance'] = []
+    #     refSpectrum_dict['absorbance'] = []
+
+    ###
+    for file_path in paths:
+        seach_text_present, extracted_line = check_and_extract_line(file_path, search_text)
+        x_axis, y_axis = find_xy(extracted_line)
+        if y_axis != signal_type and signal_type != 'reference':
+            return None, None
+
+        filename = os.path.basename(file_path)
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+
+        if x_axis == 'wavelength':
+            sample_energy = [filename]
+            wavelength_list = ['sample']
+            for line0 in lines:
+                line = line0.strip().split(" ")
+                if is_float(line[0]):
+                    wavelength = float(line[0])
+                    energy = float(line[-1])
+                    sample_energy.append(energy)
+                    wavelength_list.append(wavelength)
+            # all_energy.append(sample_energy)
+            spectrum_dict[y_axis].append(sample_energy)
+
+        elif x_axis == 'wavenumber':
+            sample_energy = []
+            wavelength_list = []
+            for line0 in lines:
+                line = line0.strip().split(" ")
+                if is_float(line[0]):
+                    energy = float(line[-1])
+                    sample_energy = [energy] + sample_energy
+                    # TODO
+                    # Fill wavelength list only for one sample file to avoid
+                    # iterative process
+                    wavenumber = float(line[0])
+                    wavelength = (1/wavenumber)* (10 ** 7)
+                    wavelength_list = [wavelength] + wavelength_list
+            wavelength_list = ['sample'] + wavelength_list
+            sample_energy = [filename] + sample_energy
+            # all_energy.append(sample_energy)
+            spectrum_dict[y_axis].append(sample_energy)
+
+    if len(spectrum_dict['reflectance']) == 0:
+        reflectance_df = None
+    else:
+        reflectance_df = pd.DataFrame(spectrum_dict['reflectance'], columns=wavelength_list)
+    if len(spectrum_dict['absorbance']) == 0:
+        absorbance_df = None
+    else:
+        absorbance_df = pd.DataFrame(spectrum_dict['absorbance'], columns=wavelength_list)
+    
+    return reflectance_df, absorbance_df
+    # df = pd.DataFrame(spectrum_dict, columns=wavelength_list)
+    # return df
+
+
+def load_refSpectrum(spectrum_paths):
+    all_energy = []
+    for file_path in spectrum_paths:
+        filename = os.path.basename(file_path)
+        sample_energy = []
+        wavelength_list = []
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+        for line0 in lines:
+            line = line0.strip().split(" ")
+            if is_float(line[1]):
+                wavelength = float(line[1])
+                energy = float(line[-1])
+                sample_energy.append(energy)
+                wavelength_list.append(wavelength)
+                pass
+        wavelength_list = ['polymer'] + wavelength_list
+        sample_energy = [filename] + sample_energy
+        all_energy.append(sample_energy)
+    refSpectrum_df = pd.DataFrame(all_energy, columns=wavelength_list)
+    return refSpectrum_df
+
+
+
+
+
+
+
+
+
+
+    

peakviz-0.1.0/src/peakviz.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: peakviz
+Version: 0.1.0
+Summary: A tool to visualize Hyperspectral data from point and imaging sensors.
+Author-email: Tasnim Tabassum Nova <tabassumnova1@gmail.com>
+Project-URL: Homepage, https://github.com/TabassumNova/PeakViz
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyQt5
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: plotly
+Dynamic: license-file
+
+# PeakViz
+This repository represents a simple workflow to visualize Hyperspectral data from point sensors: PSR and Fourier Transform Infrared Spectroscopy (FTIR) sensor. The wavelength ranges for these sensors are :
+- PSR : 350.0 - 2500.0 nm
+- FTIR : 2500.0629 - 15385.6915 nm
+
+<p align="center">
+  <img src="image1.png" width="500"/>
+</p>
+
+# Tutorial
+Coming soon ...
+
+# Acknowledgement
+This work is performed at [Helmholtz Institute Freiberg for Resource Technology](https://www.hzdr.de/db/Cms?pOid=32948&pNid=2423&pLang=en) in the [Exploration](https://www.iexplo.space/) department
+
+
+

peakviz-0.1.0/src/peakviz.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/dataloader.py
+src/point_sensor.py
+src/pre_processing.py
+src/vizualization.py
+src/peakviz.egg-info/PKG-INFO
+src/peakviz.egg-info/SOURCES.txt
+src/peakviz.egg-info/dependency_links.txt
+src/peakviz.egg-info/requires.txt
+src/peakviz.egg-info/top_level.txt
+tests/test_dataloader.py
+tests/test_imaging_sensor.py
+tests/test_vizualization.py

peakviz-0.1.0/src/peakviz.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

peakviz-0.1.0/src/peakviz.egg-info/requires.txt

@@ -0,0 +1,5 @@
+PyQt5
+numpy
+matplotlib
+pandas
+plotly

peakviz-0.1.0/src/peakviz.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+__init__
+dataloader
+point_sensor
+pre_processing
+vizualization

peakviz-0.1.0/src/point_sensor.py

@@ -0,0 +1,348 @@
+import sys
+from PyQt5.QtCore import *
+from PyQt5.QtWidgets import *
+from PyQt5.QtGui import *
+
+from .dataloader import *
+from .vizualization import *
+from .pre_processing import *
+
+class PointSensor(QScrollArea):
+
+    def __init__(self):
+        super(PointSensor, self).__init__()
+        self.widget1 = QWidget()
+        layout1 = QGridLayout(self.widget1)
+        layout1.setAlignment(Qt.AlignTop)
+
+        self.sensor = None
+        self.search_text = None #TODO: make this text from user input
+        self.reflectance_files = None
+        self.absorbance_files = None
+        self.reflectance_df = None
+        self.absorbance_df = None
+        self.batchname = ''
+        self.lib_path = None
+        self.library_df = None
+        self.spectrum_paths = None
+        self.refSpectrum_df = {}
+        self.rescaling_flag = False
+        self.average_flag = False
+        self.reflectance_rescaled_df = None
+        self.absorbance_rescaled_df = None
+        self.reflectance_averaged_df = None
+        self.absorbance_averaged_df = None
+        self.download_flag = False
+        self.setFixedWidth(500)
+        self.setFixedHeight(700)
+
+        # Choose sensor
+        self.label1 = QLabel(self.widget1)
+        self.label1.setObjectName('Choose point sensor: ')
+        self.label1.setText('Choose point sensor: ')
+        font = QFont()
+        font.setBold(True)
+        font.setPointSize(14)  
+        self.label1.setFont(font)
+        self.label1.setGeometry(QRect(10, 20, 150, 20))
+
+
+        # creating check box for choosing sensor
+        self.checkBoxSWIR = QCheckBox("VNIR/SWIR", self.widget1) 
+        self.checkBoxSWIR.setGeometry(10, 50, 100, 20) 
+        self.checkBoxMWIR = QCheckBox("MWIR/LWIR", self.widget1) 
+        self.checkBoxMWIR.setGeometry(120, 50, 100, 20)
+
+        # calling the uncheck method if any check box state is changed 
+        self.checkBoxSWIR.stateChanged.connect(self.select_sensor) 
+        self.checkBoxMWIR.stateChanged.connect(self.select_sensor) 
+
+         # Select Reflectance files
+        self.label2 = QLabel(self.widget1)
+        self.label2.setObjectName('Select single or multiple "Reflectance" files')
+        self.label2.setText('Select single or multiple "Reflectance" files')  
+        self.label2.setFont(font)
+        self.label2.setGeometry(QRect(10, 90, 300, 20))
+
+        # Button for loading Reflectance
+        self.btn1 = QPushButton(self.widget1)
+        self.btn1.setObjectName('Load Reflectance')
+        self.btn1.setText('Load Reflectance')
+        self.btn1.setGeometry(QRect(10, 120, 130, 40))
+        self.btn1.clicked.connect(self.reflectance_file_dialog)
+
+        # Message for loading Reflectance files
+        self.label3 = QLabel(self.widget1)
+        self.label3.setObjectName('Reflectance loaded')
+        self.label3.setText('')
+        self.label3.setStyleSheet("border: 0.5px solid gray;")
+        self.label3.setGeometry(QRect(150, 125, 130, 30))
+
+
+        # Label for renaming files from comment (VNIR/SWIR only)
+        self.rename_label = QLabel(self.widget1)
+        self.rename_label.setObjectName('Rename files from comment')
+        self.rename_label.setText('Rename the files (Only applicable to VNIR/SWIR)')
+        self.rename_label.setFont(font)
+        self.rename_label.setGeometry(QRect(10, 170, 350, 20))
+
+        # Checkbox for renaming
+        self.rename_checkbox = QCheckBox('Rename', self.widget1)
+        self.rename_checkbox.setGeometry(QRect(10, 195, 80, 25))
+        # self.rename_checkbox.stateChanged.connect(self.select_rename)
+
+        # Save button beside checkbox
+        self.save_button = QPushButton('Save', self.widget1)
+        self.save_button.setGeometry(QRect(100, 195, 80, 25))
+        # self.save_button.clicked.connect(self.rename_files)
+
+        # Select Absorbance files
+        self.label4 = QLabel(self.widget1)
+        self.label4.setObjectName('Select single or multiple "Absorbance" files (Optional)')
+        self.label4.setText('Select single or multiple "Absorbance" files (Optional)')  
+        self.label4.setFont(font)
+        self.label4.setGeometry(QRect(10, 235, 365, 20))
+
+        # Button for loading Absorbance
+        self.btn2 = QPushButton(self.widget1)
+        self.btn2.setObjectName('Load Absorbance')
+        self.btn2.setText('Load Absorbance')
+        self.btn2.setGeometry(QRect(10, 265, 130, 40))
+        self.btn2.clicked.connect(self.absorbance_file_dialog)
+
+        # Message for loading Absorbance files
+        self.label5 = QLabel(self.widget1)
+        self.label5.setObjectName('Absorbance loaded')
+        self.label5.setText('')
+        self.label5.setStyleSheet("border: 0.5px solid gray;")
+        self.label5.setGeometry(QRect(150, 270, 130, 30))
+
+         # Select Library file
+        self.label6 = QLabel(self.widget1)
+        self.label6.setObjectName('Select fingerprint library for the specified sensor (Optional)')
+        self.label6.setText('Select fingerprint library for the specified sensor (Optional)')  
+        self.label6.setFont(font)
+        self.label6.setGeometry(QRect(10, 310, 400, 20))
+
+        # Button for loading Library
+        self.btn3 = QPushButton(self.widget1)
+        self.btn3.setObjectName('Load Fingerprints')
+        self.btn3.setText('Load Fingerprints')
+        self.btn3.setGeometry(QRect(10, 340, 130, 40))
+        self.btn3.clicked.connect(self.open_library)
+
+        # Message for library files
+        self.label7 = QLabel(self.widget1)
+        self.label7.setObjectName('Fingerprints loaded')
+        self.label7.setText('')
+        self.label7.setStyleSheet("border: 0.5px solid gray;")
+        self.label7.setGeometry(QRect(150, 345, 130, 30))
+
+        #### test
+         # Select Reference spectrum
+        self.label8 = QLabel(self.widget1)
+        self.label8.setObjectName('Select Reference spectrum for the specified sensor (Optional)')
+        self.label8.setText('Select Reference spectrum for the specified sensor (Optional)')  
+        self.label8.setFont(font)
+        self.label8.setGeometry(QRect(10, 385, 420, 20))
+
+        # Button for loading Reference spectrum
+        self.btn4 = QPushButton(self.widget1)
+        self.btn4.setObjectName('Load Spectrums')
+        self.btn4.setText('Load Spectrums')
+        self.btn4.setGeometry(QRect(10, 415, 130, 40))
+        self.btn4.clicked.connect(self.open_refSpectrums)
+
+        # Message for Reference spectrum
+        self.label9 = QLabel(self.widget1)
+        self.label9.setObjectName('Spectrums loaded')
+        self.label9.setText('')
+        self.label9.setStyleSheet("border: 0.5px solid gray;")
+        self.label9.setGeometry(QRect(150, 420, 130, 30))
+        #########
+
+        # Select pre-processing method
+        self.label10 = QLabel(self.widget1)
+        self.label10.setObjectName('Select Pre-processing method (Optional)')
+        self.label10.setText('Select Pre-processing method (Optional)')  
+        self.label10.setFont(font)
+        self.label10.setGeometry(QRect(10, 460, 365, 20))
+
+        # creating check box for re-scaling
+        self.checkBoxRescaling = QCheckBox("Y-axis rescaling", self.widget1) 
+        self.checkBoxRescaling.setGeometry(10, 490, 160, 30)
+        self.checkBoxRescaling.stateChanged.connect(self.select_rescaling)
+
+        # creating check box for choosing sensor
+        self.checkBoxAverage = QCheckBox("Average", self.widget1) 
+        self.checkBoxAverage.setGeometry(160, 490, 160, 30)
+        self.checkBoxAverage.stateChanged.connect(self.select_average)
+
+        # Start visualization
+        self.label11 = QLabel(self.widget1)
+        self.label11.setObjectName('Data visualisation')
+        self.label11.setText('Data visualisation')  
+        self.label11.setFont(font)
+        self.label11.setGeometry(QRect(10, 530, 365, 20))
+
+        # creating check box for choosing sensor
+        self.checkBoxDownload = QCheckBox("Download as .html", self.widget1) 
+        self.checkBoxDownload.setGeometry(10, 560, 150, 30)
+        self.checkBoxDownload.stateChanged.connect(self.select_download)
+
+        # For opening data
+        self.btn5 = QPushButton(self.widget1)
+        self.btn5.setObjectName('Open Data')
+        self.btn5.setText('Open Data')
+        self.btn5.setGeometry(QRect(10, 590, 111, 40))
+        self.btn5.clicked.connect(self.open_data)
+
+        self.setWidget(self.widget1)
+        self.setWidgetResizable(True)
+        self.widget1.setLayout(layout1)
+        
+    def select_sensor(self, state):
+        if state == Qt.Checked: 
+            if self.sender() == self.checkBoxSWIR: 
+                self.checkBoxMWIR.setChecked(False) 
+                self.sensor = 'VNIR_SWIR' 
+                self.search_text = 'Measurement:'
+            elif self.sender() == self.checkBoxMWIR:  
+                self.checkBoxSWIR.setChecked(False) 
+                self.sensor = 'MWIR_LWIR' 
+                self.search_text = 'XYUNITS'
+
+    def create_batchname(self, file_path):
+        # Get the batchname
+        if self.sensor == 'VNIR_SWIR':
+            clock = 3
+        elif self.sensor == 'MWIR_LWIR':
+            clock = 4
+        while clock:
+            file_path, folder = os.path.split(file_path)
+            clock -= 1
+        self.batchname = folder
+
+    
+    def reflectance_file_dialog(self):
+        # Open the file dialog and get the selected file name
+        self.reflectance_files, _ = QFileDialog.getOpenFileNames(self)
+        if self.reflectance_files:
+            self.reflectance_df, _ = load_data(self.reflectance_files, signal_type='reflectance',
+                           search_text= self.search_text)
+            message = "Reflectance loaded" if self.reflectance_df is not None else "Error!"
+            self.label3.setText(message)
+            ###
+            if not self.batchname:
+                self.create_batchname(self.reflectance_files[0])
+        
+        
+    def absorbance_file_dialog(self):
+        # Open the file dialog and get the selected file name
+        self.absorbance_files, _ = QFileDialog.getOpenFileNames(self)
+        if self.absorbance_files:
+            _, self.absorbance_df = load_data(self.absorbance_files, signal_type='absorbance',
+                           search_text= self.search_text)
+            message = "Absorbance loaded" if self.absorbance_df is not None else "Error!"
+            self.label5.setText(message)
+            if not self.batchname:
+                self.create_batchname(self.absorbance_files[0]) 
+            
+
+    def open_library(self):
+        # Open the file dialog and get the selected excel file
+        # Load the file as pandas dataframe
+        self.lib_path, _ = QFileDialog.getOpenFileName(self)
+        if self.lib_path:
+            self.label7.setText("Library loaded")
+            self.library_df = pd.read_excel(self.lib_path)
+
+    def open_refSpectrums(self):
+        # Select one or multiple .txt files for reference spectrum
+        # Open the file dialog and get the selected .txt files
+        # Load the file as pandas dataframe
+        self.spectrum_paths, _ = QFileDialog.getOpenFileNames(self)
+        if self.spectrum_paths:
+            # self.refSpectrum_df = load_refSpectrum(self.spectrum_paths)
+            ###
+            reflectRef_df, absorbRef_df = load_data(self.spectrum_paths, signal_type='reference',
+                           search_text= 'XYUNITS')
+            if reflectRef_df is not None:
+                # self.reflectance_df = pd.concat([self.reflectance_df, reflectRef_df], axis=0)
+                self.refSpectrum_df['Reflectance'] = reflectRef_df
+            if absorbRef_df is not None:
+                # self.absorbance_df = pd.concat([self.absorbance_df, absorbRef_df], axis=0)
+                self.refSpectrum_df['Absorbance'] = absorbRef_df
+            ###
+            self.label9.setText('Spectrums loaded')
+        
+    def select_rescaling(self, state):
+        if state == Qt.Checked: 
+            if self.sender() == self.checkBoxRescaling: 
+                self.rescaling_flag = True
+                if self.reflectance_files:
+                    self.reflectance_rescaled_df = rescale_data(self.reflectance_df)
+                if self.absorbance_files:
+                    self.absorbance_rescaled_df = rescale_data(self.absorbance_df)
+
+    def select_average(self, state):
+        if state == Qt.Checked: 
+            if self.sender() == self.checkBoxAverage: 
+                self.average_flag = True
+                if self.reflectance_files:
+                    self.reflectance_averaged_df = average_data(self.reflectance_df, 
+                                                                self.reflectance_files[0],
+                                                                signal_type= 'Reflectance')
+                if self.absorbance_files:
+                    self.absorbance_averaged_df = average_data(self.absorbance_df, 
+                                                               self.absorbance_files[0],
+                                                               signal_type= 'Absorbance')
+
+    def select_download(self, state):
+        if state == Qt.Checked: 
+            if self.sender() == self.checkBoxDownload: 
+                self.download_flag = True
+            
+
+    def open_data(self):
+        df_plot = {}
+        if self.reflectance_files:
+            df_plot['Reflectance'] = (self.reflectance_df, 'Reflectance')
+        if self.absorbance_files:
+            df_plot['Absorbance'] = (self.absorbance_df, 'Absorbance')
+        if self.rescaling_flag:
+            df_plot['Reflectance (Re-scaled)'] = (self.reflectance_rescaled_df, 'Reflectance')
+            df_plot['Absorbance (Re-scaled)'] = (self.absorbance_rescaled_df, 'Absorbance')
+            pass
+
+        # This creates vizualization to plot multiple data
+        viz(self.batchname, df_plot, fingerprint_library=self.library_df, 
+            reference_Spectrums=self.refSpectrum_df,
+            sensor=self.sensor, download=self.download_flag)
+        # Check if del obj is possible
+        self.reflectance_files = None
+        self.absorbance_files = None
+        self.reflectance_df = None
+        self.absorbance_df = None
+        self.batchname = None
+        # self.library_df = None
+        # self.rescaling_flag = False
+        self.reflectance_rescaled_df = None
+        self.absorbance_rescaled_df = None
+        # self.download_flag = False
+        self.label3.setText("")
+        self.label5.setText("")
+        self.label9.setText("")
+        # self.label7.setText("")
+        # if hasattr(self, 'downloadCheckBox'):
+        self.checkBoxDownload.setChecked(False)
+        # if hasattr(self, 'averageCheckBox'):
+        self.checkBoxAverage.setChecked(False)
+
+
+
+# if __name__ == "__main__":
+#     app = QApplication(sys.argv)
+#     window = Window()
+#     window.show()
+#     sys.exit(app.exec())

peakviz-0.1.0/src/pre_processing.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pandas as pd
+import os
+
+def rescale_data(df):
+    new = []
+    for index, row in df.iterrows():
+        text = [row.iloc[0]]
+        energy = np.array(row)[1:]
+        min_val = energy.min()
+        max_val = energy.max()
+        rescaled_energy = list((energy - min_val) / (max_val - min_val))
+        new.append(text+rescaled_energy)
+
+    rescaled_df = pd.DataFrame(new, columns=list(df.columns))
+    return rescaled_df
+
+def common_prefix(strings):
+    if not strings:
+        return ""
+    
+    # Find the length of the shortest string
+    min_length = min(len(s) for s in strings)
+    
+    # Compare characters
+    for i in range(min_length):
+        if len(set(s[i] for s in strings)) > 1:
+            return strings[0][:i]
+    
+    # If we've made it here, return the whole shortest string
+    return strings[0][:min_length]
+
+def average_data(df, input_path, signal_type):
+    samples = list(df['sample'])
+    averaged_name = common_prefix(samples)
+    averaged_list = []
+    for (columnName, columnData) in df.items(): 
+        is_float = np.issubdtype(columnData.dtype, np.floating)
+        if is_float:
+            mean = columnData.mean().item()
+            averaged_list.append(mean)
+    averaged_df1 = pd.DataFrame([averaged_list], columns=list(df.columns[1:]))
+
+    ### For generating text file
+    reshaped_df = averaged_df1.melt(var_name="Wavelength (nm)", value_name="FTIR signal").reset_index(drop=True)
+    file_path, folder = os.path.split(input_path)
+    output_path = os.path.join(file_path, averaged_name+ signal_type + '.txt')
+    with open(output_path, 'w') as f:
+        f.write("XYUNITS Nanometer; "+ signal_type + "\n")
+        reshaped_df.to_csv(f, sep=' ', index=False, header=True)
+
+    averaged_df2 = pd.DataFrame([[averaged_name]+averaged_list], columns=list(df.columns))
+    return averaged_df2

peakviz-0.1.0/src/vizualization.py

@@ -0,0 +1,163 @@
+import ast
+import plotly.graph_objects as go
+import plotly.express as px
+import numpy as np
+
+
+def viz(batch_name, df_plot, fingerprint_library=None, reference_Spectrums=None,
+        sensor='', download=False):
+    fig = go.Figure()
+    buttons = []
+    start = 0
+    end = start
+    visible_dict = {}
+    y_axis_dict = {}
+    for key_index, (key, plots) in enumerate(df_plot.items()):
+        df = plots[0]
+        y_axis_dict[key] = plots[1]
+        wavelengths = list(df.columns)[1:]
+        data = []
+        max_energy = df.iloc[:, 1:].max().max() # For plotting vertical lines
+        min_energy = df.iloc[:, 1:].min().min() # For plotting vertical lines
+        for index, row in df.iterrows():
+            sample_name = list(row)[0]
+            energy = list(row)[1:]
+            graph = go.Scatter(x=wavelengths, y=energy, name = sample_name, mode='lines',
+                               visible=(key_index == 0),
+                            #    hoverinfo='x'
+                               )
+            data.append(graph)
+            fig.add_trace(graph)
+            end += 1
+        
+        # Visualisation for Reference Spectrum libraries
+        if reference_Spectrums:
+            ref_df = reference_Spectrums[key]
+            wavelengths = list(ref_df.columns)[1:]
+            for index, row in ref_df.iterrows():
+                polymer_name = list(row)[0]
+                energy = list(row)[1:]
+                graph = go.Scatter(x=wavelengths, y=energy, name = polymer_name, mode='lines',
+                                visible=(key_index == 0),
+                                #    hoverinfo='x'
+                                )
+                data.append(graph)
+                fig.add_trace(graph)
+                end += 1
+            # TODO: remove redundancy
+            max_energy = max(max_energy, ref_df.iloc[:, 1:].max().max()) # For plotting vertical lines 
+            min_energy = min(min_energy, ref_df.iloc[:, 1:].min().min()) # For plotting vertical lines  
+        
+        # Visualisation for fingerprint libraries
+        if fingerprint_library is not None:
+            lib = fingerprint_library if sensor=='imaging' else fingerprint_library[fingerprint_library['sensor'] == sensor]
+            unique_groups = lib['polymer'].unique()
+            color_map = {group: px.colors.qualitative.Light24[i % len(px.colors.qualitative.Light24)] for i, group in enumerate(unique_groups)}
+            for index, row in lib.iterrows():
+                group_name = row['polymer']
+                colour = row['colour']
+                # Check if the row['wavelengths'] is a string of ranges
+                # If yes, then plot shaded area
+                if '-' in row['wavelengths']:
+                    ranges = row['wavelengths'].strip('[]').split(',')
+                    for i, r in enumerate(ranges):
+                        r = r.strip()
+                        if '-' in r:
+                            start_range, end_range = map(float, r.split('-'))
+                            shade = go.Scatter(
+                                x=[start_range, start_range, end_range, end_range, start_range],
+                                y=[min_energy, max_energy, max_energy, min_energy, min_energy],
+                                fill='toself',
+                                fillcolor='LightSkyBlue',
+                                opacity=0.3,
+                                mode='lines',
+                                line={'color': 'LightSkyBlue'},
+                                name=group_name,
+                                legendgroup=group_name,
+                                showlegend=True if i == 0 else False,
+                                visible=(key_index == 0),
+                            )
+                        data.append(shade)
+                        fig.add_trace(shade)
+                        end += 1
+
+                else:
+                    wavelengths = [float(x) for x in ast.literal_eval(row['wavelengths'])]
+                    for i, x_value in enumerate(wavelengths):
+                        line = go.Scatter(
+                            x=[x_value]*2,  # Duplicate x values for vertical lines
+                            y=np.linspace(min_energy, max_energy, num=2).tolist(),  # Alternate y values for vertical lines
+                            mode='lines+text',
+                            name=group_name,
+                            line={'color': colour},
+                            legendgroup=group_name,
+                            # showlegend=False,
+                            showlegend=True if i == 0 else False,
+                            visible=(key_index == 0),
+                            textposition="top left",
+                        )
+                        data.append(line)
+                        fig.add_trace(line)
+                        # Add a vertical line at x=2 using data coordinates
+                        
+                        end += 1
+
+        visible_dict[key] = (start, end)
+        start = end
+
+        
+
+        
+    # Buttons for dropdown menu
+    for dd_key, limit in visible_dict.items():
+        visible = [False] * len(fig.data)
+        visible[limit[0] : limit[1]] = [True] * (limit[1]-limit[0])
+        buttons.append(dict(
+            label=dd_key,
+            method="update",
+            args=[{"visible": visible},
+                  {'yaxis': {'title': y_axis_dict[dd_key]}},
+                    {"title": f"{batch_name} : {sensor} - {dd_key}"}]
+        ))
+    
+    # fig.add_annotation(textangle=-90)
+    # Add dropdown menu
+    fig.update_layout(
+        updatemenus=[go.layout.Updatemenu(
+            buttons=buttons,
+            direction="down",
+            pad={"r": 10, "t": 10},
+            showactive=False,
+            x=0.1,
+            xanchor="left",
+            y=1.1,
+            yanchor="top"
+        )]
+    )
+
+    text = batch_name + "_" + sensor
+    fig.update_layout(
+        # yaxis_range=[0, 1],
+        xaxis_title='Wavelength',
+        # yaxis_title='Reflectance',
+        title={
+            'text': batch_name + " : " + sensor,
+            'font': {
+                'size': 24,
+                'color': 'black',
+                'family': 'Arial',
+                'weight': 'bold'
+            },
+            'x': 0.5,
+            'xanchor': 'center'
+        },
+    )
+    fig.update_layout(hovermode="x unified")
+    fig.update_traces(textposition='top center')
+
+    if download:
+        fig.write_html(text + ".html")
+     
+    fig.show()
+
+    

peakviz-0.1.0/tests/test_dataloader.py

@@ -0,0 +1,40 @@
+import pytest
+import numpy as np
+import pandas as pd
+import os
+from src import dataloader
+
+def test_is_float():
+    assert dataloader.is_float('1.23')
+    assert not dataloader.is_float('abc')
+
+def test_find_xy_reflectance():
+    line = 'wavelength reflectance'
+    x, y = dataloader.find_xy(line)
+    assert x == 'wavelength' and y == 'reflectance'
+
+def test_find_xy_absorbance():
+    line = 'wavenumber absorbance'
+    x, y = dataloader.find_xy(line)
+    assert x == 'wavenumber' and y == 'absorbance'
+
+def test_load_data(tmp_path):
+    # Create a dummy reflectance file
+    file_path = tmp_path / 'test.txt'
+    with open(file_path, 'w') as f:
+        f.write('wavelength reflectance\n')
+        f.write('1000 0.1\n')
+        f.write('1100 0.2\n')
+    reflectance_df, absorbance_df = dataloader.load_data([str(file_path)], 'reflectance', 'wavelength reflectance')
+    assert reflectance_df is not None
+    assert absorbance_df is None
+    assert 'sample' in reflectance_df.columns
+
+def test_load_refSpectrum(tmp_path):
+    file_path = tmp_path / 'ref.txt'
+    with open(file_path, 'w') as f:
+        f.write('sample 1000 0.1\n')
+        f.write('sample 1100 0.2\n')
+    df = dataloader.load_refSpectrum([str(file_path)])
+    assert df is not None
+    assert 'polymer' in df.columns or 'sample' in df.columns

peakviz-0.1.0/tests/test_imaging_sensor.py

@@ -0,0 +1,23 @@
+import pytest
+import numpy as np
+import pandas as pd
+from src import imaging_sensor
+
+def test_imaging_sensor_init():
+    sensor = imaging_sensor.ImagingSensor()
+    assert hasattr(sensor, 'widget1')
+    assert hasattr(sensor, 'hylib_dict')
+    assert sensor.hylib_dict is None
+
+def test_select_absorbance(monkeypatch):
+    sensor = imaging_sensor.ImagingSensor()
+    sensor.hylib_dict = {'dummy': pd.DataFrame(np.random.rand(2, 2))}
+    sensor.checkBoxAbsorbance = type('obj', (), {'isChecked': lambda self: True})()
+    sensor.sender = lambda: sensor.checkBoxAbsorbance
+    # Patch convert_absorbance to check if called
+    called = {}
+    def fake_convert():
+        called['yes'] = True
+    sensor.convert_absorbance = fake_convert
+    sensor.select_absorbance(Qt.Checked)
+    assert called.get('yes')

peakviz-0.1.0/tests/test_vizualization.py

@@ -0,0 +1,50 @@
+import pytest
+import numpy as np
+import pandas as pd
+import os
+from src import vizualization
+
+def test_hex_rgba():
+    # Test the hex_rgba function for correct rgba output
+    hex_color = '#FF0000'
+    transparency = 0.5
+    expected = (255, 0, 0, 0.5)
+    result = vizualization.hex_rgba(hex_color, transparency)
+    assert result == expected
+
+def test_create_masked_image(tmp_path, monkeypatch):
+    # Create dummy RGB and mask files
+    import cv2
+    rgb = np.ones((60, 60, 3), dtype=np.uint8) * 255
+    mask = np.zeros((10, 10, 1), dtype=np.uint8)
+    mask[2:8, 2:8, 0] = 1
+    rgb_path = tmp_path / 'RGB.png'
+    mask_path = tmp_path / 'mask.hdr'
+    cv2.imwrite(str(rgb_path), rgb)
+    # Patch io.load to return a dummy object with .data
+    class DummyMask:
+        def __init__(self, data):
+            self.data = data
+    monkeypatch.setattr(vizualization.io, 'load', lambda path: DummyMask(mask))
+    vizualization.create_masked_image(str(tmp_path))
+    assert os.path.exists(tmp_path / 'RGB_masked.png')
+
+def test_viz(monkeypatch):
+    # Test viz function with minimal DataFrame
+    df = pd.DataFrame({
+        'sample': ['A', 'B'],
+        1000: [0.1, 0.2],
+        1100: [0.2, 0.3]
+    })
+    df_plot = {'test': [df, 'Reflectance']}
+    # Patch fig.show to avoid opening browser
+    monkeypatch.setattr(vizualization.go.Figure, 'show', lambda self: None)
+    vizualization.viz('batch', df_plot, sensor='imaging', download=False)
+
+def test_viz_image_data(monkeypatch, tmp_path):
+    # Test viz_image_data with dummy hylib_dict
+    df = pd.DataFrame(np.random.rand(5, 5), columns=[str(i) for i in range(5)])
+    hylib_dict = {'test': df}
+    # Patch fig.show to avoid opening browser
+    monkeypatch.setattr(vizualization.go.Figure, 'show', lambda self: None)
+    vizualization.viz_image_data('batch', hylib_dict, str(tmp_path), sensor='imaging', download=False)