pyspectrace 2.0.0__py3-none-any.whl

pyspectrace/Control/Configuration/Acquisition/Communication/communicationcontrol.py

@@ -0,0 +1,34 @@
+
+class CommunicationControl:
+    def __init__(self, model, view):
+        self.model = model
+        self.view = view
+        
+        self.delay_time = 250
+
+        self.view.configurationlayout.acquisitionlayout.communicationlayout.time_integration_button.clicked.connect(
+            lambda: self.integration_time_change(
+                self.view.configurationlayout.acquisitionlayout.communicationlayout.time_integration_spinbox.value()
+                )
+            )
+        self.view.configurationlayout.acquisitionlayout.communicationlayout.acquisitiondelay_button.clicked.connect(
+            lambda: self.acquisition_delay_change(
+                self.view.configurationlayout.acquisitionlayout.communicationlayout.acquisitiondelay_spinbox.value()
+                )
+            )
+    
+    def mainloop(self):
+        self.acquire()
+
+    def acquire(self):
+        cumulative_plot = [self.model.acquire_spectrum()]       
+        self.view.plottinglayout.spectrumlayout.num_spectrum = [None]
+        self.view.plottinglayout.spectrumlayout.plot_spectrum(cumulative_plot, cumulative_plot)
+
+    def integration_time_change(self, slot_integration_value):
+        self.model.set_integration_time(slot_integration_value)
+
+    def acquisition_delay_change(self, slot_delay_value):
+        self.delay_time = slot_delay_value
+        self.model.set_acquisition_delay(slot_delay_value)
+

pyspectrace/Control/Configuration/Acquisition/Saving/savingcontrol.py

@@ -0,0 +1,190 @@
+import numpy as np
+from datetime import datetime, timedelta
+import os
+
+class SavingControl:
+    def __init__(self, model, view):
+        self.model = model
+        self.view = view
+        self.mainpath = self.view.configurationlayout.acquisitionlayout.savinglayout.combined_path_text
+        self.processed_wavelengths = None
+        self.processed_intensities = None
+
+        self.raw_wavelengths = None
+        self.raw_intensities = None
+
+        self.stateresume = True
+
+        self.current_forprogress = 0
+        self.elapsed_time = 0
+
+        # self.current_progress = 0
+        self.count_saved = 0
+
+        self.cumulative_delta_time = 0
+        self.frame_list_txt = 0
+        self.cumulative_delta_time_raw = 0
+
+        self.cumulative_delta_time_list = []
+        self.cumulative_delta_time_list_raw = []
+
+        self.delta_timestart = datetime.now()   
+        # self.delta_timestart_raw = datetime.now()
+        # self.delta_timestart = time.perf_counter()      
+        # self.delta_timestart_raw = time.perf_counter()
+        self.start_time = datetime.now()
+        self.start_time_progress = datetime.now()
+
+        self.view.configurationlayout.acquisitionlayout.savinglayout.enable_record_checkbox.stateChanged.connect(self.inittime_save_slot)
+        self.view.configurationlayout.acquisitionlayout.savinglayout.apply_button.clicked.connect(self.init_time_save)
+        self.view.configurationlayout.acquisitionlayout.savinglayout.pauseresumebuttom.clicked.connect(self.pauseresumestate)
+
+    def mainloop(self):
+        if self.view.configurationlayout.acquisitionlayout.savinglayout.status_saving:     
+            if self.stateresume:
+                _current_time = datetime.now()
+                self.elapsed_time = (_current_time - self.start_time).total_seconds()
+                
+                interval = self.view.configurationlayout.acquisitionlayout.savinglayout.interval_saving.value()
+                progress_percent = min(int((self.elapsed_time / interval) * 100), 100)
+                self.view.configurationlayout.acquisitionlayout.savinglayout.progress.setValue(progress_percent)
+                
+                
+                if self.elapsed_time >= self.view.configurationlayout.acquisitionlayout.savinglayout.interval_saving.value():
+                    self.intervalstart()
+                    self.savingtxt()
+                    self.start_time = _current_time
+                    self.current_progress = 0
+                    self.view.record_value_saved.setText(f"{self.count_saved}")
+                    self.view.configurationlayout.acquisitionlayout.savinglayout.progress.setValue(0)
+                    self.intervalend()
+            else:
+                _current_time = datetime.now()
+                self.start_time = _current_time - timedelta(seconds=self.elapsed_time)
+
+                self.delta_timestart =  _current_time - timedelta(seconds=self.elapsed_time)
+                # self.delta_timestart_raw =  _current_time - timedelta(seconds=self.elapsed_time)
+
+
+    def pauseresumestate(self):
+        if self.view.configurationlayout.acquisitionlayout.savinglayout.pauseresumebuttom.text() == "Pause":
+            self.stateresume = False
+            self.view.configurationlayout.acquisitionlayout.savinglayout.pauseresumebuttom.setText("Resume")
+
+        elif self.view.configurationlayout.acquisitionlayout.savinglayout.pauseresumebuttom.text() == "Resume":
+            self.stateresume = True
+            self.view.configurationlayout.acquisitionlayout.savinglayout.pauseresumebuttom.setText("Pause")
+
+    def intervalstart(self):
+        self.current_time = datetime.now()
+        self.current_time_raw = datetime.now()
+
+    def intervalend(self):
+        self.delta_timestart = self.delta_timeend 
+        # self.delta_timestart_raw = self.delta_timeend_raw
+    
+    def savingtxt(self):
+        processed_wavelengths, processed_intensities = self.model.acquire_spectrum()
+        raw_wavelengths, raw_intensities = self.model.acquire_spectrum_for_normalization()
+
+        self.delta_timeend = datetime.now()
+        self.delta_timeend_raw = datetime.now()
+        # self.delta_timeend = time.perf_counter()
+        # self.delta_timeend_raw = time.perf_counter()
+
+        self.delta_time = (self.delta_timeend - self.delta_timestart).total_seconds()
+        self.delta_time = np.array(self.delta_time)
+        self.delta_time = np.full(len(processed_intensities), self.delta_time)
+        
+        self.frame_list_txt = self.frame_list_txt + 1
+
+        processed_data = [processed_wavelengths, processed_intensities, self.delta_time]
+        raw_data = [raw_wavelengths, raw_intensities, self.delta_time]
+
+        processed_data_transposed = list(map(list, zip(*processed_data)))
+        raw_data_transposed = list(map(list, zip(*raw_data)))
+
+        filename = self.current_time.strftime("%Y-%m-%d_%H-%M-%S")
+
+        self.mainpath = self.view.configurationlayout.acquisitionlayout.savinglayout.combined_path_text
+        os.makedirs(os.path.join(self.mainpath, 'processed'), exist_ok=True)
+        os.makedirs(os.path.join(self.mainpath, 'raw'), exist_ok=True)
+
+        save_path_processed = os.path.join(self.mainpath, 'processed', f'{self.frame_list_txt}-index-processed_spectrum_{filename}.txt')
+        save_path_raw = os.path.join(self.mainpath, 'raw', f'{self.frame_list_txt}-index-raw_spectrum_{filename}.txt')
+
+        for sublist in processed_data_transposed:
+            sublist.append(self.current_time.strftime("%Y-%m-%d %H-%M-%S-%f"))
+        try:
+            with open(save_path_processed, "w") as file:
+                file.write(("[wavelength, intensities, timedelta, date, time]") + "\n")
+                file.write((">>>>>Begin Processed Spectral Data<<<<<") + "\n")
+                for sublist in processed_data_transposed:
+                    file.write(" ".join(map(str, sublist)) + "\n")
+                file.write((">>>>>End Processed Spectral Data<<<<<") + "\n")
+                self.count_saved = self.count_saved + 1
+        except:
+            print("error txt processed saved")
+            pass
+
+        for sublist in raw_data_transposed:
+            sublist.append(self.current_time.strftime("%Y-%m-%d %H-%M-%S-%f"))
+        try:
+            with open(save_path_raw, "w") as file:
+                file.write(("[wavelength, intensities, timedelta, date, time]") + "\n")
+                file.write((">>>>>Begin Processed Spectral Data<<<<<") + "\n")
+                for sublist in raw_data_transposed:
+                    file.write(" ".join(map(str, sublist)) + "\n")
+                file.write((">>>>>End Processed Spectral Data<<<<<") + "\n")
+            self.count_saved = self.count_saved + 1
+        except:
+            print("error txt raw saved")
+            pass
+
+
+    def inittime_save_slot(self, state):
+        if state == 2:
+            self.view.configurationlayout.acquisitionlayout.savinglayout.inittime_save = datetime.now().strftime("%Y-%m-%d_%H-%M-%S_%f")
+            self.view.configurationlayout.acquisitionlayout.savinglayout.update_combined_text()
+            self.mainpath = self.view.configurationlayout.acquisitionlayout.savinglayout.combined_path_text
+
+        if state == 0:
+            self.count_saved = 0
+            self.view.record_value_saved.setText(f"{self.count_saved}")
+    
+    def init_time_save(self):
+            if self.view.configurationlayout.acquisitionlayout.savinglayout.syncsensorgram.isChecked():
+                self.view.configurationlayout.plottinglayout.sensorgramlayout.reset_button.click()
+
+            self.processed_wavelengths = None
+            self.processed_intensities = None
+
+            self.raw_wavelengths = None
+            self.raw_intensities = None
+
+            # self.current_progress = 0
+            self.current_forprogress = 0
+            self.count_saved = 0
+            
+
+            self.cumulative_delta_time = 0
+            self.frame_list_txt = 0
+            self.cumulative_delta_time_raw = 0
+
+            self.delta_timestart = datetime.now()     
+            # self.delta_timestart = time.perf_counter()      
+            self.cumulative_delta_time_list = []
+            # self.delta_timestart_raw = datetime.now()
+            # self.delta_timestart_raw = time.perf_counter()
+            self.cumulative_delta_time_list_raw = []
+            self.start_time = datetime.now()
+            self.start_time_progress = datetime.now()
+        
+            
+
+    def onesecond_left(self, start_time):
+        current_time = datetime.now()
+        elapsed_time = (current_time - start_time).total_seconds()
+        if elapsed_time >= 0.1:
+            return True
+        return False

pyspectrace/Control/Configuration/Acquisition/acquisitioncontrol.py

@@ -0,0 +1,10 @@
+from pyspectrace.Control.Configuration.Acquisition.Communication.communicationcontrol import CommunicationControl
+from pyspectrace.Control.Configuration.Acquisition.Saving.savingcontrol import SavingControl
+class AcquisitionControl:
+    def __init__(self, 
+                 model, 
+                 view):
+        self.model = model
+        self.view = view
+        self.communicationcontrol = CommunicationControl(model, view)
+        self.savingcontrol = SavingControl(model, view)

pyspectrace/Control/Configuration/Plotting/Sensorgramcontrol/__init__.py

@@ -0,0 +1,6 @@
+from PyQt5.QtCore import QTimer
+
+class SpectrumControl:
+    def __init__(self, model, view):
+        self.model = model
+        self.view = view

pyspectrace/Control/Configuration/Plotting/Sensorgramcontrol/sensorgramcontrol.py

@@ -0,0 +1,192 @@
+import matplotlib.pyplot as plt
+from PyQt5.QtWidgets import QFileDialog
+import os
+import csv
+from datetime import datetime
+
+class SensorgramControl:
+    def __init__(self, model, view):
+        self.model = model
+        self.view = view
+        self.current_time = datetime.now()
+        # self.view.configurationlayout.plottinglayout.sensorgramlayout.autoscale_y.clicked.connect(
+        #     self.view.plottinglayout.sensorgramlayout.setscale)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.autoscale_y.clicked.connect(
+            self.view.plottinglayout.sensorgramlayout.autoscale_y)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.autoscale_x.clicked.connect(
+            self.view.plottinglayout.sensorgramlayout.autoscale_x)
+        # self.view.configurationlayout.plottinglayout.sensorgramlayout.update_fixed_range.clicked.connect(self.update_fixed_range)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.update_fixed_range.clicked.connect(self.update_fixed_range_merge)
+        # self.view.configurationlayout.plottinglayout.sensorgramlayout.update_fixed_range_merge.clicked.connect(self.update_fixed_range_merge)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.reset_button.clicked.connect(self.show_confirmation)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.savesensorgram.clicked.connect(self.savesensorgram)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.plotsensorgram.clicked.connect(self.plotsensorgram)
+        self.view.configurationlayout.plottinglayout.sensorgramlayout.select_time_unit.currentIndexChanged.connect(self.time_unit)
+
+        self.inittime = 0
+    def mainloop(self):
+        x = self.view.plottinglayout.sensorgramlayout.gaussianshiftpeak_list
+        if any(val > 600 for row in x for val in row):
+            # do something
+            print("trigger arduino to take an action!")
+        pass
+
+
+    def time_unit(self):
+        if self.view.configurationlayout.plottinglayout.sensorgramlayout.select_time_unit.currentIndex() == 0:
+            self.view.plottinglayout.sensorgramlayout.time_unit_update(1/1000)
+            self.view.plottinglayout.sensorgramlayout.pI.setLabel('bottom', 'Milisecond (ms)')
+        if self.view.configurationlayout.plottinglayout.sensorgramlayout.select_time_unit.currentIndex() == 1:
+            self.view.plottinglayout.sensorgramlayout.time_unit_update(1)
+            self.view.plottinglayout.sensorgramlayout.pI.setLabel('bottom', 'Time (s)')
+        if self.view.configurationlayout.plottinglayout.sensorgramlayout.select_time_unit.currentIndex() == 2:
+            self.view.plottinglayout.sensorgramlayout.pI.setLabel('bottom', 'Minute (m)')
+            self.view.plottinglayout.sensorgramlayout.time_unit_update(1*60)
+    
+    def update_fixed_range(self):
+        min = self.view.configurationlayout.plottinglayout.sensorgramlayout.min_range_input.value()
+        max = self.view.configurationlayout.plottinglayout.sensorgramlayout.max_range_input.value()
+        self.view.plottinglayout.sensorgramlayout.setscale_y(min, max)
+
+    def update_fixed_range_merge(self):
+        min = self.view.configurationlayout.plottinglayout.sensorgramlayout.min_range_input.value()
+        max = self.view.configurationlayout.plottinglayout.sensorgramlayout.max_range_input.value()
+        self.view.plottinglayout.sensorgramlayout.mergesetscale_y(min, max)
+    
+    def plotsensorgram(self):
+        descriptor, time, name, color = self.sensorgram_data() 
+        descriptor_list = []
+        time_list = []
+        name_list = []
+        color_list = []
+        for i in range(len(descriptor)):
+            for j in range (len(descriptor[i])):
+                descriptor_list.append(descriptor[i][j])
+                time_list.append(time[i][j])
+                name_list.append(name[i][j])
+                color_list.append(color[i][j].name())
+
+        for i in range(len(descriptor_list)):
+            plt.figure(figsize=(10, 6))
+            plt.plot(time_list[i], descriptor_list[i], label=name_list[i], color=color_list[i])
+            plt.legend()
+            plt.title(f'Plot for "{name_list[i]}"')
+            plt.show()
+
+    def savesensorgram(self):
+        descriptor, time, name, color = self.sensorgram_data() 
+        descriptor_list = []
+        time_list = []
+        name_list = []
+        color_list = []
+        for i in range(len(descriptor)):
+            for j in range (len(descriptor[i])):
+                descriptor_list.append(descriptor[i][j])
+                time_list.append(time[i][j])
+                name_list.append(name[i][j])
+                color_list.append(color[i][j].name())
+
+        folder = QFileDialog.getExistingDirectory(None, "Pilih Folder untuk Menyimpan CSV")
+        if not folder:
+            print("Penyimpanan dibatalkan. Tidak ada folder yang dipilih.")
+            return
+        
+        for i in range(len(descriptor_list)):
+            file_name = f'{i}{self.current_time.strftime("%Y-%m-%d_%H-%M-%S_%f")}{name_list[i]}.csv'
+            file_path = os.path.join(folder, file_name)
+
+            # Tulis data ke file CSV
+            with open(file_path, mode='w', newline='') as file:
+                writer = csv.writer(file)
+                # Menulis header
+                writer.writerow(['Time', 'Descriptor', 'Label', 'Color'])
+                
+                # Menulis data (loop berdasarkan sub-data `time_list[i]` dan `descriptor_list[i]`)
+                for j in range(len(time_list[i])):
+                    writer.writerow([time_list[i][j], descriptor_list[i][j], name_list[i], color_list[i]])
+            print(f"Data disimpan ke: {file_path}")
+        
+    
+
+
+    def show_confirmation(self):
+        # reply = QMessageBox.question(self.view, 'Info', 'Are you sure to reset sensorgram?', 
+        #                              QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+
+        # if reply == QMessageBox.Yes:
+            # self.resetsensorgram()
+        self.resetsensorgram()
+    
+    def resetsensorgram(self):
+        self.view.plottinglayout.sensorgramlayout.frame_list_gaussianshiftpeak.clear()
+        self.view.plottinglayout.sensorgramlayout.gaussianshiftpeak_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_lorentzianshiftpeak.clear()
+        self.view.plottinglayout.sensorgramlayout.lorentzianshiftpeak_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshiftpeak.clear()
+        self.view.plottinglayout.sensorgramlayout.polynomialshiftpeak_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_polyshiftpeak.clear()
+        self.view.plottinglayout.sensorgramlayout.polyshiftpeak_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshift.clear()
+        self.view.plottinglayout.sensorgramlayout.polynomialshift_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_lorentzianshiftpeakwidth.clear()
+        self.view.plottinglayout.sensorgramlayout.lorentzianshiftpeakwidth_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_gaussianshiftpeakwidth.clear()
+        self.view.plottinglayout.sensorgramlayout.gaussianshiftpeakwidth_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshiftpeakwidth.clear()
+        self.view.plottinglayout.sensorgramlayout.polynomialshiftpeakwidth_list.clear()
+
+        self.view.plottinglayout.sensorgramlayout.frame = 0
+        self.view.plottinglayout.sensorgramlayout.clearplot_plot_obj()
+
+    def sensorgram_data(self):
+        descriptor = [
+                self.view.plottinglayout.sensorgramlayout.gaussianshiftpeak_list,
+                self.view.plottinglayout.sensorgramlayout.lorentzianshiftpeak_list,
+                self.view.plottinglayout.sensorgramlayout.polynomialshiftpeak_list,
+                self.view.plottinglayout.sensorgramlayout.polyshiftpeak_list,
+                self.view.plottinglayout.sensorgramlayout.polynomialshift_list,
+                self.view.plottinglayout.sensorgramlayout.lorentzianshiftpeakwidth_list,
+                self.view.plottinglayout.sensorgramlayout.gaussianshiftpeakwidth_list,
+                self.view.plottinglayout.sensorgramlayout.polynomialshiftpeakwidth_list,
+                ]
+        
+        time = [
+                self.view.plottinglayout.sensorgramlayout.frame_list_gaussianshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.frame_list_lorentzianshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.frame_list_polyshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshift,
+                self.view.plottinglayout.sensorgramlayout.frame_list_lorentzianshiftpeakwidth,
+                self.view.plottinglayout.sensorgramlayout.frame_list_gaussianshiftpeakwidth,
+                self.view.plottinglayout.sensorgramlayout.frame_list_polynomialshiftpeakwidth,
+                ]
+
+        name = [
+                self.view.plottinglayout.sensorgramlayout.name_gaussianpeakfitting,
+                self.view.plottinglayout.sensorgramlayout.name_lorentzianpeakfitting,
+                self.view.plottinglayout.sensorgramlayout.name_polynomialpeakfitting,
+                self.view.plottinglayout.sensorgramlayout.name_polypeakfitting,
+                self.view.plottinglayout.sensorgramlayout.name_polynomialfitting,
+                self.view.plottinglayout.sensorgramlayout.name_lorentzianpeakwidthfitting,
+                self.view.plottinglayout.sensorgramlayout.name_gaussianpeakwidthfitting,
+                self.view.plottinglayout.sensorgramlayout.name_polynomialpeakwidthfitting,
+                ]
+        
+        color = [
+                self.view.plottinglayout.sensorgramlayout.color_gaussianshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.color_lorentzianshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.color_polynomialshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.color_polyshiftpeak,
+                self.view.plottinglayout.sensorgramlayout.color_polynomialshift,
+                self.view.plottinglayout.sensorgramlayout.color_lorentzianshiftpeakwidth,
+                self.view.plottinglayout.sensorgramlayout.color_gaussianshiftpeakwidth,
+                self.view.plottinglayout.sensorgramlayout.color_polynomialshiftpeakwidth,
+            ]
+        return descriptor, time, name, color

pyspectrace/Control/Configuration/Plotting/Spectrumcontrol/spectrumcontrol.py

@@ -0,0 +1,99 @@
+from datetime import datetime, timedelta
+from PyQt5.QtWidgets import QMessageBox
+import pyqtgraph as pg
+import random
+
+class SpectrumControl:
+    def __init__(self, model, view):
+        self.model = model
+        self.view = view       
+
+        self.start_time = datetime.now()
+        self.current_forprogress = 0
+        self.elapsed_time = 0
+
+        self.start_time_foraccumulated = datetime.now()
+        self.current_foraccumulated = 0
+
+        self.accumulated_wavelengths = []
+        self.accumulated_intensities = []
+        self.accumulated_second = []
+
+        self.state_accumulated = False
+        self.view.configurationlayout.plottinglayout.spectrumlayout.start_acquire.setEnabled(True)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.pause_acquire.setEnabled(False)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.restart.clicked.connect(self.show_confirmation)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.plot.clicked.connect(self.plot)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.start_acquire.clicked.connect(self.truestate)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.pause_acquire.clicked.connect(self.falsestate)
+
+        self.view.configurationlayout.plottinglayout.spectrumlayout.fit_interest_x.clicked.connect(
+            self.view.plottinglayout.spectrumlayout.autoscale_x)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.fit_interest_y.clicked.connect(
+            self.view.plottinglayout.spectrumlayout.autoscale_y)
+    
+    def truestate(self):
+        self.state_accumulated = True
+        self.view.configurationlayout.plottinglayout.spectrumlayout.start_acquire.setEnabled(False)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.pause_acquire.setEnabled(True)
+
+    def falsestate(self):
+        self.state_accumulated = False
+        self.view.configurationlayout.plottinglayout.spectrumlayout.start_acquire.setEnabled(True)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.pause_acquire.setEnabled(False)
+
+    def mainloop(self):
+        if self.state_accumulated:
+            _current_time = datetime.now()
+            self.elapsed_time = (_current_time - self.start_time).total_seconds()
+            interval = self.view.configurationlayout.plottinglayout.spectrumlayout.interval_acquire.value()
+            progress_percent = min(int((self.elapsed_time / interval) * 100), 100)
+            self.view.configurationlayout.plottinglayout.spectrumlayout.progress.setValue(progress_percent)
+            if self.elapsed_time >= self.view.configurationlayout.plottinglayout.spectrumlayout.interval_acquire.value():
+                self.intervalstart()
+                self.accumulated_second.append((_current_time - self.start_time_foraccumulated).total_seconds())
+                self.accumulating_spectrum()
+                self.start_time = _current_time
+                self.view.configurationlayout.plottinglayout.spectrumlayout.progress.setValue(0)
+        else:
+            _current_time = datetime.now()
+            self.start_time = _current_time - timedelta(seconds=self.elapsed_time)
+            
+    def spectrum_data(self):
+        spectrum = [
+                self.view.plottinglayout.spectrumlayout.wavelengths,
+                self.view.plottinglayout.spectrumlayout.intensities,
+                ]
+        return spectrum[0][0], spectrum[1][0]
+
+    def intervalstart(self):
+        self.current_time = datetime.now()
+
+    def accumulating_spectrum(self):
+        wavelengths, intensities = self.spectrum_data()
+        self.accumulated_wavelengths.append(wavelengths)
+        self.accumulated_intensities.append(intensities)
+        self.view.configurationlayout.plottinglayout.spectrumlayout.sum.setText(f"{len(self.accumulated_intensities)}")
+
+    def show_confirmation(self):
+        reply = QMessageBox.question(self.view, 'Info', 'Are you sure to reset plot?', 
+                                     QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+
+        if reply == QMessageBox.Yes:
+            self.restart()
+
+    def restart(self):
+        self.accumulated_wavelengths = []
+        self.accumulated_intensities = []
+        self.view.configurationlayout.plottinglayout.spectrumlayout.sum.setText(f"{len(self.accumulated_intensities)}")
+
+    def plot(self):
+        self.window = pg.GraphicsLayoutWidget(show=True, title="Spectrum Over Time")
+        self.window.setBackground('w')
+        self.plotting = self.window.addPlot()
+        self.plotting.addLegend()
+        for i, (wavelengths, intensities) in enumerate(zip(self.accumulated_wavelengths, self.accumulated_intensities)):
+            color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+            pen = pg.mkPen(color=color, width=1)
+            self.plotting.plot(wavelengths, intensities, pen=pen, name=f"{self.accumulated_second[i]:.2f} second")
+            

pyspectrace/Control/Configuration/Plotting/plottingcontrol.py

@@ -0,0 +1,11 @@
+from pyspectrace.Control.Configuration.Plotting.Spectrumcontrol.spectrumcontrol import SpectrumControl
+from pyspectrace.Control.Configuration.Plotting.Sensorgramcontrol.sensorgramcontrol import SensorgramControl
+class PlottingLayout:
+    def __init__(self, 
+                 model, 
+                 view):
+        self.model = model
+        self.view = view
+        self.spectrumcontrol = SpectrumControl(model, view)
+        self.sensorgramcontrol = SensorgramControl(model, view)
+