debug mesh + update_rk (verry slow mesh)

src/Meshing/Internal.py

@@ -50,20 +50,23 @@ class InternalMeshing(AMeshingTool):
         elif limites[0] == limites[1]:
             return reach
 
-        self.st_to_m(reach, limites)
+        # we never modify original profiles, we work on copies
-        self.interpolate_transversal_step(reach,
+        m_profiles= self.st_to_m(reach, limites)
-                                          limites,
+        new_profiles = self.interpolate_transversal_step(m_profiles,
-                                          step)
+                                                         step)
-        self.purge_aligned_points(reach)
 
-        return reach
+        for new_profiles2 in new_profiles:
+            for p in new_profiles2:
+                p.purge_aligned_points()
+
+        return new_profiles
 
     def st_to_m(self, reach, limites):
 
         gl = reach.compute_guidelines()
-        profiles = reach.profiles[limites[0]:limites[1]+1]
+        profiles = [reach.profiles[i].copy()
-
+                    for i in range(limites[0], limites[1]+1)
-        print(profiles)
+                    ]
 
         # we make sure that the lines are in the left-to-right order
         guide_list = [
@@ -86,9 +89,9 @@ class InternalMeshing(AMeshingTool):
             for i in range(len(guide_list) - 1):
                 index1 = p.named_point_index(guide_list[i])
                 index2 = p.named_point_index(guide_list[i+1])
-                if index2 - index1 > max_values[i + 1]:
+                if index2 - index1 > max_values[i+1]:
-                    max_values[i + 1] = index2 - index1
+                    max_values[i+1] = index2 - index1
-                    max_values_index[i + 1] = j
+                    max_values_index[i+1] = j
             index1 = p.named_point_index(guide_list[-1])
             index2 = len(p) - 1
             if index2 - index1 > max_values[-1]:
@@ -104,46 +107,44 @@ class InternalMeshing(AMeshingTool):
                 self.compl_sect(profiles[isect+1],
                                 profiles[isect],
                                 gl1[i], gl2[i])
+        return profiles
 
     def interpolate_transversal_step(self,
-                                     reach,
+                                     profiles,
-                                     limites,
                                      step):
         # calcul number of intermediate profiles
         np = []
-        for i in range(limites[0], limites[1]):
+        for i in range(len(profiles)-1):
-            np.append(int((reach.profiles[i+1].rk -
+            np.append(int((profiles[i+1].rk -
-                           reach.profiles[i].rk) / step) - 1)
+                           profiles[i].rk) / step) - 1)
             if np[-1] < 0:
                 np[-1] = 0
 
-        d = []  # ratios
+        new_profiles = []
-        p = []  # new profiles
+        for i in range(len(profiles)-1):
-        ptr = int(limites[0])
+            new_profiles2 = []
-        for i in range(limites[1] - limites[0]):
             d = 1.0/float(np[i]+1)
-            ptr0 = ptr
             for j in range(np[i]):
-                p = reach.profiles[ptr0].copy()
+                p = profiles[i].copy()
                 # RATIO entre les deux sections initiales
                 dj = float(j+1)*d
-                ptr += 1  # next profile, original
+                for k in range(len(profiles[i].points)):
-                for k in range(len(reach.profiles[ptr0].points)):
+                    p.points[k].x = profiles[i].points[k].x + \
-                    p.points[k].x = reach.profiles[ptr0].points[k].x + \
+                        dj*(profiles[i+1].points[k].x -
-                        dj*(reach.profiles[ptr].points[k].x -
+                            profiles[i].points[k].x)
-                            reach.profiles[ptr0].points[k].x)
+                    p.points[k].y = profiles[i].points[k].y + \
-                    p.points[k].y = reach.profiles[ptr0].points[k].y + \
+                        dj*(profiles[i+1].points[k].y -
-                        dj*(reach.profiles[ptr].points[k].y -
+                            profiles[i].points[k].y)
-                            reach.profiles[ptr0].points[k].y)
+                    p.points[k].z = profiles[i].points[k].z + \
-                    p.points[k].z = reach.profiles[ptr0].points[k].z + \
+                        dj*(profiles[i+1].points[k].z -
-                        dj*(reach.profiles[ptr].points[k].z -
+                            profiles[i].points[k].z)
-                            reach.profiles[ptr0].points[k].z)
+                    p.rk = profiles[i].rk + \
-                    p.rk = reach.profiles[ptr0].rk + \
+                        dj*(profiles[i+1].rk -
-                        dj*(reach.profiles[ptr].rk -
+                            profiles[i].rk)
-                            reach.profiles[ptr0].rk)
                     p.name = f'interpol{p.rk}'
-                reach.insert_profile(ptr, p)
+                new_profiles2.append(p)
-            ptr += 1  # next profile, original
+            new_profiles.append(new_profiles2)
+        return new_profiles
 
     def compl_sect(self, sect1, sect2, tag1, tag2):
         # sect1: reference section
@@ -281,14 +282,14 @@ class InternalMeshing(AMeshingTool):
                   origin_value=0.0,
                   orientation=0):
         if reach is None or len(reach.profiles) == 0:
-            return reach
+            return []
 
         nprof = reach.number_profiles
         if origin >= nprof or origin < 0:
             logger.warning(
                 f"Origin outside reach"
             )
-            return reach
+            return reach.get_rk()
 
         # orientation is the orintation of the bief:
         # 1: up -> downstream
@@ -301,7 +302,8 @@ class InternalMeshing(AMeshingTool):
         else:
             sgn = sign(reach.profiles[-1].rk - reach.profiles[0].rk)
 
-        reach.profiles[origin].rk = origin_value
+        rk = [0.0]*nprof
+        rk[origin] = origin_value
 
         if origin < nprof - 1:
             for i in range(origin+1, nprof):
@@ -312,8 +314,7 @@ class InternalMeshing(AMeshingTool):
                 d2 = reach.profiles[i-1].named_point(
                     directrices[1]
                 ).dist_2d(reach.profiles[i].named_point(directrices[1]))
-                reach.profiles[i].rk = reach.profiles[i-1].rk \
+                rk[i] = rk[i-1] + (sgn * (d1 + d2) / 2)
-                    + (sgn * (d1 + d2) / 2)
         if origin > 0:
             for i in reversed(range(0, origin)):
                 # 2D
@@ -323,9 +324,6 @@ class InternalMeshing(AMeshingTool):
                 d2 = reach.profiles[i+1].named_point(
                     directrices[1]
                 ).dist_2d(reach.profiles[i].named_point(directrices[1]))
-                reach.profiles[i].rk = reach.profiles[i+1].rk \
+                rk[i] = rk[i+1] - (sgn * (d1 + d2) / 2)
-                    - (sgn * (d1 + d2) / 2)
 
-    def purge_aligned_points(self, reach):
+        return rk
-        for p in reach.profiles:
-            p.purge_aligned_points()

src/Model/Geometry/PointXYZ.py

@@ -278,7 +278,7 @@ class PointXYZ(Point):
             id=-1,
             name=self.name,
             x=self.x, y=self.y, z=self.z,
-            profile=self.profile,
+            profile=self._profile,
             status=self._status
         )
         if self.is_deleted():
@@ -406,13 +406,3 @@ class PointXYZ(Point):
             d = np.sqrt(abs(a2 - pow((c2 - b2 + a2) / (2*np.sqrt(c2)), 2)))
 
         return d
-
-    def copy(self):
-        p = PointXYZ(self.x,
-                     self.y,
-                     self.z,
-                     self.name,
-                     self._profile,
-                     self._status)
-        p.sl = self.sl
-        return p

src/Model/Geometry/ProfileXYZ.py

@@ -1109,14 +1109,12 @@ class ProfileXYZ(Profile, SQLSubModel):
             self.point(i+1).z = 0.5 * self.point(i).z + 0.5 * self.point(i+2).z
 
     def copy(self):
-        p = ProfileXYZ(self.id,
+        p = ProfileXYZ(id=self.id,
-                       self.name,
+                       name=self.name,
-                       self.rk,
+                       rk=self.rk,
-                       self.reach,
+                       reach=self.reach,
-                       self.num,
+                       num=self.num,
-                       0,
+                       status=self._status)
-                       0, 0,
-                       self._status)
         for i, k in enumerate(self.points):
             p.insert_point(i, k.copy())
 

src/Model/Geometry/Reach.py

@@ -220,6 +220,26 @@ class Reach(SQLSubModel):
         )
         self.modified()
 
+    def hard_delete(self, indexes):
+        """Delete some elements in profile list
+
+        Args:
+            indexes: The list of index to delete
+
+        Returns:
+            Nothing.
+        """
+        self._profiles = list(
+            map(
+                lambda p: p[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self._profiles)
+                )
+            )
+        )
+        self.modified()
+
     def delete_profiles(self, profiles):
         """Delete some elements in profile list
 

src/View/Geometry/Table.py

@@ -250,12 +250,12 @@ class GeometryReachTableModel(PamhyrTableModel):
         self.layoutAboutToBeChanged.emit()
         self.layoutChanged.emit()
 
-    def meshing(self, mesher, data):
+    def meshing(self, mesher, data, tableView):
         self.layoutAboutToBeChanged.emit()
 
         self._undo.push(
             MeshingCommand(
-                self._data, mesher, data, "mesh"
+                self._data, mesher, data, tableView
             )
         )
 
@@ -266,8 +266,8 @@ class GeometryReachTableModel(PamhyrTableModel):
         self.layoutAboutToBeChanged.emit()
 
         self._undo.push(
-            MeshingCommand(
+            UpdateRKCommand(
-                self._data, mesher, data, "update_rk"
+                self._data, mesher, data
             )
         )
 

src/View/Geometry/UndoCommand.py

@@ -22,8 +22,10 @@ from copy import deepcopy
 from tools import trace, timer, logger_exception
 
 from PyQt5.QtWidgets import (
-    QMessageBox, QUndoCommand, QUndoStack, QTableView
+    QMessageBox, QUndoCommand, QUndoStack, QTableView,
 )
+from PyQt5.QtCore import (QItemSelection, QItemSelectionRange,
+                          QItemSelectionModel)
 
 from Model.Geometry import Reach
 from Model.Except import exception_message_box
@@ -227,47 +229,109 @@ class ImportCommand(QUndoCommand):
                 self._reach.insert_profile(self._row, profile)
 
 
-class MeshingCommand(QUndoCommand):
+class UpdateRKCommand(QUndoCommand):
-    def __init__(self, reach, mesher, data, command):
+    def __init__(self, reach, mesher, data):
         QUndoCommand.__init__(self)
 
         self._reach = reach
         self._data = data
         self._mesher = mesher
-        self._command = command
+        self._rks = reach.get_rk()
 
-        self._profiles = [p.copy() for p in reach.profiles]
+        self._new_rks = None
-        self._profiles.reverse()
-
-        self._new_profiles = None
 
     def undo(self):
-        self._reach.purge()
+            for rk, profile in zip(self._rks, self._reach.profiles):
+                profile.rk = rk
 
-        for profile in self._profiles:
+    def redo(self):
-            self._reach.insert_profile(0, profile)
+        if self._new_rks is None:
+            self._new_rks = self._mesher.update_rk(
+                self._reach,
+                **self._data
+            )
+
+        for rk, profile in zip(self._new_rks, self._reach.profiles):
+            profile.rk = rk
+
+class MeshingCommand(QUndoCommand):
+    def __init__(self, reach, mesher, data, tableView):
+        QUndoCommand.__init__(self)
+
+        self._reach = reach
+        self._data = data
+        self._limites = data["limites"]
+        self._mesher = mesher
+
+        self._new_profiles = None
+        self._new_profiles_indexes = None
+        self._tableView = tableView
+        self._indexes = tableView.selectionModel().selection()
+
+        rows = list(
+            set(
+                (i.row() for i in tableView.selectedIndexes())
+            )
+        )
+        self._selected_rk = [self._reach.profile(r).rk for r in rows]
+        self._new_indexes = None
+
+    def undo(self):
+        self._reach.hard_delete(self._new_profiles_indexes)
+
+        # Update selection
+        selection = self._tableView.selectionModel()
+        selection.select(
+            self._indexes,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
 
     def redo(self):
         if self._new_profiles is None:
-            if self._command == "update_rk":
+            self._new_profiles = self._mesher.meshing(
-                self._mesher.update_rk(
+                self._reach,
-                    self._reach,
+                **self._data
-                    **self._data
+            )
-                )
-            else:
-                self._mesher.meshing(
-                    self._reach,
-                    **self._data
-                )
 
-            self._new_profiles = [p.copy() for p in self._reach.profiles]
+        if self._new_profiles_indexes is None:
-            self._new_profiles.reverse()
+            k = self._limites[0]
-        else:
+            self._new_profiles_indexes = []
-            self._reach.purge()
+            for i in range(self._limites[1] - self._limites[0]):
+                k += 1
+                for p in self._new_profiles[i]:
+                    self._new_profiles_indexes.append(k)
+                    k += 1
 
-            for profile in self._new_profiles:
+        k = self._limites[0]
-                self._reach.insert_profile(0, profile)
+        for i in range(self._limites[1] - self._limites[0]):
+            k += 1
+            for p in self._new_profiles[i]:
+                self._reach.insert_profile(k, p)
+                k += 1
 
+        # Update selection
+        if self._new_indexes is None:
+            ind = []
+            for i in range(self._reach.number_profiles):
+                if self._reach.profile(i).rk in self._selected_rk:
+                    ind.append(i)
+            self._tableView.setFocus()
+            self._new_indexes = QItemSelection()
+            if len(ind) > 0:
+                for i in ind:
+                    self._new_indexes.append(QItemSelectionRange(
+                        self._tableView.model().index(i, 0)
+                    ))
+
+        selection = self._tableView.selectionModel()
+        selection.select(
+            self._new_indexes,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
 
 class PurgeCommand(QUndoCommand):
     def __init__(self, reach, np_purge):

src/View/Geometry/UpdateRKDialog.py

@@ -64,8 +64,17 @@ class UpdateRKDialog(PamhyrDialog):
                 self._end_dir = self._gl[i]
 
         self._orientation = 0
-        self._origin = self._reach.profile(0)
+        r = self.parent.tableView\
-        self._origin_value = self._reach.profile(0).rk
+                .selectionModel()\
+                .selectedRows()
+        if len(r) < 1:
+            self._origin = self._reach.profile(0)
+            self._origin_value = self._reach.profile(0).rk
+            self._origin_index = 0
+        else:
+            self._origin = self._reach.profile(r[0].row())
+            self._origin_value = self._reach.profile(r[0].row()).rk
+            self._origin_index = r[0].row()
 
         self._init_default_values_profiles()
         self._init_default_values_guidelines()
@@ -80,6 +89,8 @@ class UpdateRKDialog(PamhyrDialog):
             .connect(
                 self.changed_profile
             )
+        self.find(QComboBox, "comboBox_origin")\
+            .setCurrentIndex(self._origin_index)
 
         buttonbox = self.find(QButtonGroup, "buttonGroup_orientation")
 

src/View/Geometry/Window.py

@@ -323,29 +323,10 @@ class GeometryWindow(PamhyrWindow):
             logger_exception(e)
             return
 
-        ind = []
-        for i in range(self._reach.number_profiles):
-            if self._reach.profile(i).rk in selected_rk:
-                ind.append(i)
-        self.tableView.setFocus()
-        selection = self.tableView.selectionModel()
-        index = QItemSelection()
-        if len(ind) > 0:
-            for i in ind:
-                index.append(QItemSelectionRange(
-                    self.tableView.model().index(i, 0)
-                ))
-                selection.select(
-                    index,
-                    QItemSelectionModel.Rows |
-                    QItemSelectionModel.ClearAndSelect |
-                    QItemSelectionModel.Select
-                )
-
     def _edit_meshing(self, data):
         try:
             mesher = InternalMeshing()
-            self._table.meshing(mesher, data)
+            self._table.meshing(mesher, data, self.tableView)
         except Exception as e:
             logger_exception(e)
 
@@ -370,7 +351,7 @@ class GeometryWindow(PamhyrWindow):
 
     def _update_rk(self, data):
         try:
-            mesher = MeshingWithMageMailleurTT()
+            mesher = InternalMeshing()
             self._table.update_rk(mesher, data)
         except Exception as e:
             logger_exception(e)