geometry: Put graphic 2 into PlotKPC class.

src/View/Geometry/GeometryWindow.py

@@ -18,6 +18,7 @@ from PyQt5.QtWidgets import (
 )
 
 from View.Geometry.PlotXY import PlotXY
+from View.Geometry.PlotKPC import PlotKPC
 from View.Geometry.mainwindow_ui_reach import Ui_MainWindow
 from View.Geometry import qtableview_reach
 from View.Geometry import window_profileXYZ
@@ -221,6 +222,8 @@ class GeometryWindow(QMainWindow, WindowToolKit):
         self.list_row = []
 
     def graphic_1(self):
+        self.tableView.model().blockSignals(True)
+
         self.plot_xy = PlotXY(
             canvas = self.ui.canvas_1,
             data = self._reach,
@@ -228,110 +231,33 @@ class GeometryWindow(QMainWindow, WindowToolKit):
         )
         self.plot_xy.draw()
 
-    @timer
+        self.tableView.model().blockSignals(False)
+
     def graphic_2(self):
         self.tableView.model().blockSignals(True)
 
-        self.ui.canvas_2.axes.cla()
-        self.ui.canvas_2.axes.grid(color='grey', linestyle='--', linewidth=0.5)
-        self.ui.canvas_2.axes.set_xlabel(
-            _translate("MainWindow_reach", "Kp (m)"), color='green', fontsize=12
-        )
-        self.ui.canvas_2.axes.set_ylabel(
-            _translate("MainWindow_reach", "Cote (m)"), color='green', fontsize=12
-        )
-
-        kp = self._reach.get_kp()
-        z_min = self._reach.get_z_min()
-        z_max = self._reach.get_z_max()
-
-        self.line_kp_zmin_zmax = self.ui.canvas_2.axes.vlines(
-            x=kp,
-            ymin=z_min, ymax=z_max,
-            color='r', lw=1.
-        )
-
-        self.plot_selected_2, = self.ui.canvas_2.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color='b', lw=1.8
-        )
-        self.plot_selected_2.set_visible(False)
-
-        self.before_plot_selected_2, = self.ui.canvas_2.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color='k', lw=1.6, linestyle='--'
-        )
-        self.before_plot_selected_2.set_visible(False)
-
-        self.after_plot_selected_2, = self.ui.canvas_2.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color='m', lw=1.6, linestyle='--'
-        )
-        self.after_plot_selected_2.set_visible(False)
-
-        kp = self._reach.get_kp()
-        self.line_kp_zgl = []
-        for z in self._reach.get_guidelines_z():
-            # Is incomplete guideline?
-            if len(z) != len(kp):
-                continue
-
-            self.line_kp_zgl.append(
-                self.ui.canvas_2.axes.plot(
-                    kp, z, lw=1.
-                )
-            )
-
-        self.line_kp_zmin, = self.ui.canvas_2.axes.plot(
-            kp, z_min,
-            linestyle=":", lw=1.8,
-            color='lightgrey'
+        self.plot_kpc = PlotKPC(
+            canvas = self.ui.canvas_2,
+            data = self._reach,
+            toolbar = self.ui.toolbar_2
         )
+        self.plot_kpc.draw()
 
         self.tableView.model().blockSignals(False)
 
-        self.ui.canvas_2.figure.tight_layout()
-        self.ui.canvas_2.figure.canvas.draw_idle()
-        self.ui.toolbar_2.update()
-
-    def update_graphic_1(self):
+    def update_graphic_2(self):
         self.tableView.model().blockSignals(True)
 
-        self.plot_xy.update()
+        self.plot_kpc.update()
 
         self.tableView.model().blockSignals(False)
 
-    @timer
-    def update_graphic_2(self):
+    def update_graphic_1(self):
         self.tableView.model().blockSignals(True)
 
-        kp = self._reach.get_kp()
-        z_min = self._reach.get_z_min()
-        z_max = self._reach.get_z_max()
-
-        self.line_kp_zmin.set_data(kp, z_min)
-
-        self.line_kp_zmin_zmax.remove()
-        self.line_kp_zmin_zmax = self.ui.canvas_2.axes.vlines(
-            x=kp,
-            ymin=z_min, ymax=z_max,
-            color='r', lw=1.
-        )
-
-        try:
-            for i in range(len(self.line_kp_zgl)):
-                self.line_kp_zgl[i][0].set_data(
-                    kp, self._tablemodel.z_complete_guideline()[i]
-                )
-        except Exception as e:
-            print(f"Failed to update graphic 2: {e}")
+        self.plot_xy.update()
 
         self.tableView.model().blockSignals(False)
-        self.ui.canvas_2.axes.autoscale_view(True, True, True)
-        self.ui.canvas_2.figure.canvas.draw_idle()
 
     @timer
     def graphic_3(self):
@@ -552,42 +478,12 @@ class GeometryWindow(QMainWindow, WindowToolKit):
         self.tableView.model().blockSignals(False)
 
     def select_plot_graphic_2(self, ind: int):
-        kp_i = self._reach.profile(ind).kp
-        z_min_i = self._reach.profile(ind).z_min()
-        z_max_i = self._reach.profile(ind).z_max()
-
-        if 0 <= ind < self._tablemodel.rowCount():
-            self.plot_selected_2.set_data((kp_i, kp_i),
-                                          (z_min_i, z_max_i))
-            self.plot_selected_2.set_visible(True)
-
-    def select_before_plot_selected_2(self, ind: int):
-        if 0 <= ind < self._tablemodel.rowCount():
-            kp_i = self._reach.profile(ind).kp
-            z_min_i = self._reach.profile(ind).z_min()
-            z_max_i = self._reach.profile(ind).z_max()
-
-            self.before_plot_selected_2.set_data(
-                (kp_i, kp_i),
-                (z_min_i, z_max_i)
-            )
+        self.tableView.model().blockSignals(True)
 
-            self.before_plot_selected_2.set_visible(True)
-            self.ui.canvas_2.figure.canvas.draw_idle()
+        self.plot_kpc.update(ind=ind)
 
-    def select_after_plot_selected_2(self, ind: int):
-        if 0 <= ind < self._tablemodel.rowCount():
-            kp_i = self._reach.profile(ind).kp
-            z_min_i = self._reach.profile(ind).z_min()
-            z_max_i = self._reach.profile(ind).z_max()
+        self.tableView.model().blockSignals(False)
 
-            self.after_plot_selected_2.set_data(
-                (kp_i, kp_i),
-                (z_min_i, z_max_i)
-            )
-
-            self.after_plot_selected_2.set_visible(True)
-            self.ui.canvas_2.figure.canvas.draw_idle()
 
     def select_row_profile_slider(self, ind: int = 0):
         if self.tableView is not None:
@@ -614,16 +510,7 @@ class GeometryWindow(QMainWindow, WindowToolKit):
             self.select_plot_graphic_2(row)
 
             self.plot_xy.update(ind = row)
-
-            if row == 0:
-                self.before_plot_selected_2.set_visible(False)
-                self.select_after_plot_selected_2(row + 1)
-            elif 0 < row < self._tablemodel.rowCount() - 1:
-                self.select_before_plot_selected_2(row - 1)
-                self.select_after_plot_selected_2(row + 1)
-            elif row == self._tablemodel.rowCount() - 1:
-                self.after_plot_selected_2.set_visible(False)
-                self.select_before_plot_selected_2(row - 1)
+            self.plot_kpc.update(ind = row)
 
             self.tableView.model().blockSignals(False)
             self.update_graphic_3(row)

src/View/Geometry/PlotKPC.py

+# -*- coding: utf-8 -*-
+
+from tools import timer
+from View.Plot.APlot import APlot
+
+from PyQt5.QtCore import (
+    QCoreApplication
+)
+
+_translate = QCoreApplication.translate
+
+class PlotKPC(APlot):
+    def __init__(self, canvas=None, data=None, toolbar=None):
+        super(PlotKPC, self).__init__(
+            canvas=canvas,
+            data=data,
+            toolbar=toolbar
+        )
+
+        self.line_kp_zgl = []
+        self.line_kp_zmin = None
+        self.line_kp_zmin_zmax = None
+
+        self.before_plot_selected = None
+        self.plot_selected = None
+        self.after_plot_selected = None
+
+    @timer
+    def draw(self):
+        self.canvas.axes.cla()
+        self.canvas.axes.grid(color='grey', linestyle='--', linewidth=0.5)
+        self.canvas.axes.set_xlabel(
+            _translate("MainWindow_reach", "Kp (m)"),
+            color='green', fontsize=12
+        )
+        self.canvas.axes.set_ylabel(
+            _translate("MainWindow_reach", "Cote (m)"),
+            color='green', fontsize=12
+        )
+
+        kp = self.data.get_kp()
+        z_min = self.data.get_z_min()
+        z_max = self.data.get_z_max()
+
+        self.line_kp_zmin_zmax = self.canvas.axes.vlines(
+            x=kp,
+            ymin=z_min, ymax=z_max,
+            color='r', lw=1.
+        )
+
+        self.plot_selected, = self.canvas.axes.plot(
+            (kp[0], kp[0]),
+            (z_min[0], z_max[0]),
+            color='b', lw=1.8
+        )
+        self.plot_selected.set_visible(False)
+
+        self.before_plot_selected, = self.canvas.axes.plot(
+            (kp[0], kp[0]),
+            (z_min[0], z_max[0]),
+            color='k', lw=1.6, linestyle='--'
+        )
+        self.before_plot_selected.set_visible(False)
+
+        self.after_plot_selected, = self.canvas.axes.plot(
+            (kp[0], kp[0]),
+            (z_min[0], z_max[0]),
+            color='m', lw=1.6, linestyle='--'
+        )
+        self.after_plot_selected.set_visible(False)
+
+        kp = self.data.get_kp()
+        self.line_kp_zgl = []
+        for z in self.data.get_guidelines_z():
+            # Is incomplete guideline?
+            if len(z) != len(kp):
+                continue
+
+            self.line_kp_zgl.append(
+                self.canvas.axes.plot(
+                    kp, z, lw=1.
+                )
+            )
+
+        self.line_kp_zmin, = self.canvas.axes.plot(
+            kp, z_min,
+            linestyle=":", lw=1.8,
+            color='lightgrey'
+        )
+
+        self.canvas.figure.tight_layout()
+        self.canvas.figure.canvas.draw_idle()
+        self.toolbar.update()
+
+    @timer
+    def update(self, ind=None):
+        if ind:
+            before = ind - 1
+            after = ind + 1
+
+            self.before_plot_selected.set_visible(False)
+            self.plot_selected.set_visible(False)
+            self.after_plot_selected.set_visible(False)
+
+            if 0 <= before < self.data.number_profiles:
+                kp_i = self.data.profile(before).kp
+                z_min_i = self.data.profile(before).z_min()
+                z_max_i = self.data.profile(before).z_max()
+
+                self.before_plot_selected.set_data(
+                    (kp_i, kp_i),
+                    (z_min_i, z_max_i)
+                )
+                self.before_plot_selected.set_visible(True)
+
+            if 0 <= ind < self.data.number_profiles:
+                kp_i = self.data.profile(ind).kp
+                z_min_i = self.data.profile(ind).z_min()
+                z_max_i = self.data.profile(ind).z_max()
+
+                self.plot_selected.set_data(
+                    (kp_i, kp_i),
+                    (z_min_i, z_max_i)
+                )
+                self.plot_selected.set_visible(True)
+
+            if 0 <= after < self.data.number_profiles:
+                kp_i = self.data.profile(after).kp
+                z_min_i = self.data.profile(after).z_min()
+                z_max_i = self.data.profile(after).z_max()
+
+                self.after_plot_selected.set_data(
+                    (kp_i, kp_i),
+                    (z_min_i, z_max_i)
+                )
+                self.after_plot_selected.set_visible(True)
+
+            self.canvas.figure.canvas.draw_idle()
+        else:
+            kp = self.data.get_kp()
+            z_min = self.data.get_z_min()
+            z_max = self.data.get_z_max()
+
+            self.line_kp_zmin.set_data(kp, z_min)
+
+            self.line_kp_zmin_zmax.remove()
+            self.line_kp_zmin_zmax = self.canvas.axes.vlines(
+                x=kp,
+                ymin=z_min, ymax=z_max,
+                color='r', lw=1.
+            )
+
+            z_complete = self.data.get_guidelines_z()
+            try:
+                for i in range(len(self.line_kp_zgl)):
+                    self.line_kp_zgl[i][0].set_data(
+                        kp, z_complete[i]
+                    )
+            except Exception as e:
+                print(f"Failed to update graphic 2: {e}")
+
+            self.canvas.axes.autoscale_view(True, True, True)
+            self.canvas.figure.canvas.draw_idle()