Add first Sprint version

requirements.txt

@@ -1,7 +1,9 @@
 PyQt5 >= 5.13
 python-vlc
 PyQtGraph
-pyechart
+PyQtChart
 influxdb
 opencv-python
-pandas
+pandas
+psutil
+scipy

run.py

@@ -6,6 +6,31 @@
 #     [email protected] (Seong Min Chae)
 #     [email protected] (Jongjin Oh)
 
-from src.__main__ import main
+import multiprocessing as mp
+from src.nd01 import clock, ND01MainWindow
 
-main()
+
+if __name__ == '__main__':
+    import sys
+    from PyQt5.QtWidgets import QApplication
+    print(f'Start time: {time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())}')
+
+    mp.freeze_support()
+    q = Queue()
+    _q = Queue()
+
+    _producer = producer
+
+    p = Process(name='clock', target=clock, args=(q,), daemon=True)
+    _p = Process(name='producer', target=_producer, args=(_q,), daemon=True)
+
+    p.start()
+    _p.start()
+
+    os.makedirs(f'{JS06Settings.get("data_csv_path")}', exist_ok=True)
+    os.makedirs(f'{JS06Settings.get("target_csv_path")}', exist_ok=True)
+    os.makedirs(f'{JS06Settings.get("image_save_path")}', exist_ok=True)
+
+    app = QApplication(sys.argv)
+    window = ND01MainWindow(q, _q)
+    sys.exit(app.exec())

src/auto_file_delete.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+#
+# Copyright 2021-2022 9th grade 5th class.
+#
+# Authors:
+#     [email protected]
+
+import os
+import psutil
+import shutil
+
+from PyQt5.QtWidgets import (QDialog, QApplication, QMessageBox)
+from PyQt5 import uic
+
+from model import JS08Settings
+
+
+def byte_transform(bytes, to, bsize=1024):
+    """
+    Unit conversion of byte received from shutil
+
+    :return: Capacity of the selected unit (int)
+    """
+    unit = {'KB': 1, 'MB': 2, 'GB': 3, 'TB': 4}
+    r = float(bytes)
+    for i in range(unit[to]):
+        r = r / bsize
+    return int(r)
+
+
+class FileAutoDelete(QDialog):
+
+    def __init__(self):
+        super().__init__()
+
+        ui_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                               'resources/auto_file_delete.ui')
+        uic.loadUi(ui_path, self)
+
+        # self.setFixedSize(self.width(), self.height())
+
+        drive = []
+        # Save all of the user's drives in drive variable.
+        for i in range(len(psutil.disk_partitions())):
+            drive.append(str(psutil.disk_partitions()[i])[18:19])
+
+        self.calendarWidget.activated.connect(self.showDate)
+
+        self.path = None
+        self.date = None
+        self.date_convert = None
+
+        self.exit_pushButton.clicked.connect(self.exit_click)
+
+    def exit_click(self):
+        self.close()
+
+    def showDate(self, date):
+        self.date = date.toString('yyMMdd')
+        self.date_convert = date.toString('yyyy/MM/dd')
+        self.check_file_date(os.path.join(JS08Settings.get('image_save_path'),
+                                          'vista'))
+
+    def check_file_date(self, path: str):
+        is_old = []
+
+        for f in os.listdir(path):
+            print(f)
+            if int(f) <= int(self.date):
+                is_old.append(int(f))
+
+        if is_old:
+            dlg = QMessageBox.question(self, 'Warning', f'Delete folder before {self.date_convert} ?',
+                                       QMessageBox.Yes | QMessageBox.No)
+            if dlg == QMessageBox.Yes:
+                self.delete_select_date(path, is_old)
+        else:
+            QMessageBox.information(self, 'Information', 'There is no data before the selected date.')
+
+    def delete_select_date(self, path: str, folder: list):
+        """
+        Delete the list containing the folder name
+
+        :param path: Path to proceed with a auto-delete
+        :param folder: Data older than the date selected as the calendarWidget
+        """
+
+        for i in range(len(folder)):
+            a = os.path.join(path, str(folder[i]))
+            shutil.rmtree(a)
+            print(f'{a} delete complete.')
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    window = FileAutoDelete()
+    window.show()
+    sys.exit(app.exec_())

src/cal_ext_coef.py

@@ -0,0 +1,132 @@
+import itertools
+import os
+
+import numpy as np
+import pandas as pd
+import traceback
+import warnings
+
+import scipy
+from scipy.optimize import curve_fit
+
+curved_flag = True
+hanhwa_dist = []
+hanhwa_x = []
+hanhwa_r = []
+hanhwa_g = []
+hanhwa_b = []
+
+
+def select_max_rgb(r, g, b):
+    c_list = [r, g, b]
+
+    c_index = c_list.index(max(c_list))
+
+    if c_index == 0:
+        select_color = 'red'
+    elif c_index == 1:
+        select_color = 'green'
+    else:
+        select_color = 'blue'
+    # select_color = 'green'
+
+    return select_color
+
+
+def cal_curve(hanhwa: pd.DataFrame):
+    # hanhwa = pd.read_csv(f"{rgbsavedir}/{epoch}.csv")
+    # print(hanhwa)
+    global hanhwa_opt_r, hanhwa_opt_g, hanhwa_opt_b
+    hanhwa = hanhwa.sort_values(by=['distance'])
+    hanhwa_dist = hanhwa[['distance']].squeeze().to_numpy()
+    hanhwa_x = np.linspace(hanhwa_dist[0], hanhwa_dist[-1], 100, endpoint=True)
+    hanhwa_x.sort()
+    hanhwa_r = hanhwa[['r']].squeeze().to_numpy()
+    hanhwa_g = hanhwa[['g']].squeeze().to_numpy()
+    hanhwa_b = hanhwa[['b']].squeeze().to_numpy()
+
+    r1_init = hanhwa_r[0] * 0.7
+    g1_init = hanhwa_g[0] * 0.7
+
+    b1_init = hanhwa_b[0] * 0.7
+    r2_init = hanhwa_r[-1] * 1.3
+    g2_init = hanhwa_g[-1] * 1.3
+    b2_init = hanhwa_b[-1] * 1.3
+
+    select_color = select_max_rgb(r2_init, g2_init, b2_init)
+
+    r_ext_init = [r1_init, r2_init, 1]
+    g_ext_init = [g1_init, g2_init, 1]
+    b_ext_init = [b1_init, b2_init, 1]
+
+    try:
+        hanhwa_opt_r, hanhwa_cov_r = curve_fit(func, hanhwa_dist, hanhwa_r, p0=r_ext_init, maxfev=5000)
+        hanhwa_opt_g, hanhwa_cov_g = curve_fit(func, hanhwa_dist, hanhwa_g, p0=g_ext_init, maxfev=5000)
+        hanhwa_opt_b, hanhwa_cov_b = curve_fit(func, hanhwa_dist, hanhwa_b, p0=b_ext_init, maxfev=5000)
+
+        # hanhwa_opt_r, hanhwa_cov_r = curve_fit(func, hanhwa_dist, hanhwa_r, p0=r_ext_init)
+        # hanhwa_opt_g, hanhwa_cov_g = curve_fit(func, hanhwa_dist, hanhwa_g, p0=g_ext_init)
+        # hanhwa_opt_b, hanhwa_cov_b = curve_fit(func, hanhwa_dist, hanhwa_b, p0=b_ext_init)
+
+    except RuntimeError:
+        # Optimal parameters not found: Number of calls to function has reached maxfev = 5000.
+        # 이 에러는 타겟의 RGB에 대해 최적의 기울기를 찾지 못하여 발생하는 에러로,
+        # 타겟이 이상할 때 대게 발생함.
+
+        # print(traceback.format_exc())
+        pass
+
+    list1 = []
+    list2 = []
+    list3 = []
+
+    list1.append(hanhwa_opt_r[0])
+    list1.append(hanhwa_opt_g[0])
+    list1.append(hanhwa_opt_b[0])
+
+    list2.append(hanhwa_opt_r[1])
+    list2.append(hanhwa_opt_g[1])
+    list2.append(hanhwa_opt_b[1])
+
+    list3.append(hanhwa_opt_r[2])
+    list3.append(hanhwa_opt_g[2])
+    list3.append(hanhwa_opt_b[2])
+
+    # hanhwa_err_r = np.sqrt(np.diag(hanhwa_cov_r))
+    # hanhwa_err_g = np.sqrt(np.diag(hanhwa_cov_g))
+    # hanhwa_err_b = np.sqrt(np.diag(hanhwa_cov_b))
+
+    # print_result(hanhwa_opt_r, hanhwa_opt_g, hanhwa_opt_b, hanhwa_err_r, hanhwa_err_g, hanhwa_err_b)
+
+    # print(f"Red channel: {extcoeff_to_vis(hanhwa_opt_r[2], hanhwa_err_r[2], 3)} km")
+    # print(f"Green channel: {extcoeff_to_vis(hanhwa_opt_g[2], hanhwa_err_g[2], 3)} km")
+    # print(f"Blue channel: {extcoeff_to_vis(hanhwa_opt_b[2], hanhwa_err_b[2], 3)} km")
+
+    # os.makedirs(extsavedir, exist_ok=True)
+
+    return list1, list2, list3, select_color
+
+
+# @staticmethod
+def func(x, c1, c2, a):
+    warnings.filterwarnings('ignore')
+    return c2 + (c1 - c2) * np.exp(-a * x)
+
+
+# def print_result(opt_r, opt_g, opt_b, err_r, err_g, err_b):
+#     print(f'Red channel: (',
+#           f'C1: {opt_r[0]:.2f} ± {err_r[0]:.2f}, ',
+#           f'C2: {opt_r[1]:.2f} ± {err_r[1]:.2f}, ',
+#           f'alpha: {opt_r[2]:.2f} ± {err_r[2]:.2f})')
+#     print(f'Green channel: (',
+#           f'C1: {opt_g[0]:.2f} ± {err_g[0]:.2f}, ',
+#           f'C2: {opt_g[1]:.2f} ± {err_g[1]:.2f}, ',
+#           f'alpha: {opt_g[2]:.2f} ± {err_g[2]:.2f})')
+#     print(f'Blue channel: (',
+#           f'C1: {opt_b[0]:.2f} ± {err_b[0]:.2f}, ',
+#           f'C2: {opt_b[1]:.2f} ± {err_b[1]:.2f}, ',
+#           f'alpha: {opt_b[2]:.2f} ± {err_b[2]:.2f})')
+
+
+# def extcoeff_to_vis(optimal, error, coeff=3.912):
+#     return coeff / (optimal + np.array((1, 0, -1)) * error)