Translate: Add short RK name.

doc/tools/PamhyrDoc.cls

@@ -11,7 +11,8 @@
 \usepackage[absolute]{textpos}
 \usepackage{titlesec}
 \usepackage{amssymb}
-\usepackage{tcolorbox}
+\usepackage[minted,xparse,breakable]{tcolorbox}
+\usepackage{pmboxdraw}
 
 \usepackage{enumitem}
 \setlist[enumerate]{itemsep=-0.5em}
@@ -140,7 +141,7 @@
 \setminted[llvm]{breaklines,fontsize=\footnotesize,encoding=utf8}
 
 %% Add box arrond of minted
-\BeforeBeginEnvironment{minted}{\begin{tcolorbox}[boxsep=0pt, left=0.1cm, right=0.1cm, arc=0pt, boxrule=0.5pt, colback=white]}%
+\BeforeBeginEnvironment{minted}{\begin{tcolorbox}[breakable, boxsep=0pt, left=0.1cm, right=0.1cm, arc=0pt, boxrule=0.5pt, colback=white]}%
 \AfterEndEnvironment{minted}{\end{tcolorbox}}%
 
 \makeatletter

src/Meshing/Mage.py

@@ -363,7 +363,7 @@ class MeshingWithMageMailleurTT(AMeshingTool):
             self.import_m_file(reach, m_file)
             return reach
 
-    def update_kp(self, reach,
+    def update_rk(self, reach,
                   step: float = 50,
                   limites=[-1, -1],
                   origin=0,
@@ -371,7 +371,8 @@ class MeshingWithMageMailleurTT(AMeshingTool):
                   lplan: bool = False,
                   lm: int = 3,
                   linear: bool = False,
-                  origin_value=0.0):
+                  origin_value=0.0,
+                  orientation=0):
         if reach is None or len(reach.profiles) == 0:
             return reach
 
@@ -396,11 +397,11 @@ class MeshingWithMageMailleurTT(AMeshingTool):
             logger.info(
                 f"! {self._exe_path()} " +
                 f"{st_file} {m_file} " +
-                f"update_kp " +
+                f"update_rk " +
                 f"{str(step)} " +
                 f"{limites[0]} {limites[1]} " +
                 f"{directrices[0]} {directrices[1]} " +
-                f"{lplan} {lm} {linear} " +
+                f"{orientation} {lm} {linear} " +
                 f"{origin} "
             )
             proc.start(
@@ -410,10 +411,10 @@ class MeshingWithMageMailleurTT(AMeshingTool):
                         str,
                         [
                             st_file, m_file,
-                            "update_kp", step,
+                            "update_rk", step,
                             limites[0], limites[1],
                             directrices[0], directrices[1],
-                            lplan, lm, linear, origin, origin_value
+                            orientation, lm, linear, origin, origin_value
                         ]
                     )
                 )

src/Model/BoundaryCondition/BoundaryCondition.py

@@ -315,6 +315,9 @@ class BoundaryCondition(SQLSubModel):
             self._data.sort(reverse=_reverse, key=key)
         self._status.modified()
 
+    def index(self, bc):
+        self._data.index(bc)
+
     def get_i(self, index):
         return self.data[index]
 

src/Model/Friction/Friction.py

@@ -43,8 +43,8 @@ class Friction(SQLSubModel):
 
         self._name = name
         self._edge = None
-        self._begin_kp = 0.0
+        self._begin_rk = 0.0
-        self._end_kp = 0.0
+        self._end_rk = 0.0
         self._begin_strickler = None
         self._end_strickler = None
 
@@ -54,8 +54,8 @@ class Friction(SQLSubModel):
           CREATE TABLE friction(
             id INTEGER NOT NULL PRIMARY KEY,
             ind INTEGER NOT NULL,
-            begin_kp REAL NOT NULL,
+            begin_rk REAL NOT NULL,
-            end_kp REAL NOT NULL,
+            end_rk REAL NOT NULL,
             reach INTEGER NOT NULL,
             begin_strickler INTEGER NOT NULL,
             end_strickler INTEGER NOT NULL,
@@ -69,6 +69,12 @@ class Friction(SQLSubModel):
 
     @classmethod
     def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute("ALTER TABLE friction RENAME COLUMN begin_kp TO begin_rk")
+                execute("ALTER TABLE friction RENAME COLUMN end_kp TO end_rk")
+
         return True
 
     @classmethod
@@ -80,7 +86,7 @@ class Friction(SQLSubModel):
         stricklers = data["stricklers"].stricklers
 
         table = execute(
-            "SELECT id, ind, begin_kp, end_kp, " +
+            "SELECT id, ind, begin_rk, end_rk, " +
             "begin_strickler, end_strickler " +
             f"FROM friction WHERE reach = {reach.id}"
         )
@@ -102,8 +108,8 @@ class Friction(SQLSubModel):
             # Create friction
             sec = cls(status=status)
             sec.edge = reach
-            sec.begin_kp = row[2]
+            sec.begin_rk = row[2]
-            sec.end_kp = row[3]
+            sec.end_rk = row[3]
             sec.begin_strickler = bs
             sec.end_strickler = es
 
@@ -124,11 +130,11 @@ class Friction(SQLSubModel):
 
         execute(
             "INSERT INTO " +
-            "friction(id, ind, begin_kp, end_kp, " +
+            "friction(id, ind, begin_rk, end_rk, " +
             "reach, begin_strickler, end_strickler) " +
             "VALUES (" +
             f"{self.id}, {ind}, " +
-            f"{self._begin_kp}, {self._end_kp}, " +
+            f"{self._begin_rk}, {self._end_rk}, " +
             f"{self._edge.id}, " +
             f"{b_s_id}, {e_s_id}" +
             ")"
@@ -157,10 +163,10 @@ class Friction(SQLSubModel):
     def edge(self, edge):
         self._edge = edge
         if (edge is not None and
-            self._begin_kp == 0.0 and
+            self._begin_rk == 0.0 and
-                self._end_kp == 0.0):
+                self._end_rk == 0.0):
-            self._begin_kp = self._edge.reach.get_kp_min()
+            self._begin_rk = self._edge.reach.get_rk_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            self._end_rk = self._edge.reach.get_rk_max()
         self._status.modified()
 
     def has_edge(self):
@@ -176,45 +182,45 @@ class Friction(SQLSubModel):
         return self.has_edge() and self.has_coefficient()
 
     @property
-    def begin_kp(self):
+    def begin_rk(self):
-        return self._begin_kp
+        return self._begin_rk
 
-    @begin_kp.setter
+    @begin_rk.setter
-    def begin_kp(self, begin_kp):
+    def begin_rk(self, begin_rk):
         if self._edge is None:
-            self._begin_kp = begin_kp
+            self._begin_rk = begin_rk
         else:
-            _min = self._edge.reach.get_kp_min()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= begin_kp <= _max:
+            if _min <= begin_rk <= _max:
-                self._begin_kp = begin_kp
+                self._begin_rk = begin_rk
 
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
         if self._edge is None:
-            self._end_kp = end_kp
+            self._end_rk = end_rk
         else:
-            _min = self._edge.reach.get_kp_min()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= end_kp <= _max:
+            if _min <= end_rk <= _max:
-                self._end_kp = end_kp
+                self._end_rk = end_rk
 
         self._status.modified()
 
-    def __contains__(self, kp):
+    def __contains__(self, rk):
-        return self.contains_kp(kp)
+        return self.contains_rk(rk)
 
-    def contains_kp(self, kp):
+    def contains_rk(self, rk):
         return (
-            self._begin_kp <= kp <= self._end_kp
+            self._begin_rk <= rk <= self._end_rk
         )
 
     @property

src/Model/Friction/FrictionList.py

@@ -44,7 +44,7 @@ class FrictionList(PamhyrModelList):
             logger.info(f"Update friction TABLE from {version}")
             cls._db_update_0_0_1(execute, version)
 
-        return True
+        return cls._update_submodel(execute, version)
 
     @classmethod
     def _db_load(cls, execute, data=None):

src/Model/Geometry/Profile.py

@@ -31,7 +31,7 @@ class Profile(object):
     _id_cnt = 0
 
     def __init__(self, id: int = -1, num: int = 0,
-                 kp: float = 0.0, name: str = "",
+                 rk: float = 0.0, name: str = "",
                  code1: int = 0, code2: int = 0,
                  _type: str = "", reach=None,
                  status=None):
@@ -49,7 +49,7 @@ class Profile(object):
         self._num = int(num)
         self._code1 = int(code1)
         self._code2 = int(code2)
-        self._kp = float(kp)
+        self._rk = float(rk)
         self._name = str(name)
         self._reach = reach
         self._sl = None
@@ -136,16 +136,16 @@ class Profile(object):
         return len(self.points)
 
     @property
-    def kp(self):
+    def rk(self):
         """
         Returns:
             Kilometer point.
         """
-        return self._kp
+        return self._rk
 
-    @kp.setter
+    @rk.setter
-    def kp(self, value: float):
+    def rk(self, value: float):
-        self._kp = float(value)
+        self._rk = float(value)
         self._status.modified()
 
     @property

src/Model/Geometry/ProfileXYZ.py

@@ -41,7 +41,7 @@ class ProfileXYZ(Profile, SQLSubModel):
     def __init__(self,
                  id: int = -1,
                  name: str = "",
-                 kp: float = 0.,
+                 rk: float = 0.,
                  reach=None,
                  num=0,
                  nb_point: int = 0,
@@ -53,7 +53,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             num: The number of this profile
             code1: The interpolation code 1
             code2: The interpolation code 2
-            kp: Kilometer point
+            rk: Kilometer point
             name: The name of profile
 
         Returns:
@@ -63,7 +63,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             id=id,
             num=num,
             name=name,
-            kp=kp,
+            rk=rk,
             code1=code1, code2=code2,
             _type="XYZ",
             reach=reach,
@@ -78,7 +78,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             ind INTEGER NOT NULL,
             name TEXT,
             reach INTEGER NOT NULL,
-            kp REAL NOT NULL,
+            rk REAL NOT NULL,
             num INTEGER NOT NULL,
             code1 INTEGER NOT NULL,
             code2 INTEGER NOT NULL,
@@ -94,7 +94,8 @@ class ProfileXYZ(Profile, SQLSubModel):
     def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
-            if int(release) < 2:
+            rl = int(release)
+            if rl < 2:
                 execute(
                     """
                     ALTER TABLE geometry_profileXYZ
@@ -103,6 +104,14 @@ class ProfileXYZ(Profile, SQLSubModel):
                     """
                 )
 
+            if rl < 11:
+                execute(
+                    """
+                    ALTER TABLE geometry_profileXYZ
+                    RENAME COLUMN kp TO rk
+                    """
+                )
+
         return cls._update_submodel(execute, version)
 
     @classmethod
@@ -112,7 +121,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         reach = data["reach"]
 
         table = execute(
-            "SELECT id, ind, name, kp, num, code1, code2, sl " +
+            "SELECT id, ind, name, rk, num, code1, code2, sl " +
             "FROM geometry_profileXYZ " +
             f"WHERE reach = {reach.id}"
         )
@@ -121,7 +130,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             id = row[0]
             ind = row[1]
             name = row[2]
-            kp = row[3]
+            rk = row[3]
             num = row[5]
             code1 = row[5]
             code2 = row[6]
@@ -129,7 +138,7 @@ class ProfileXYZ(Profile, SQLSubModel):
 
             new = cls(
                 id=id, num=num,
-                name=name, kp=kp,
+                name=name, rk=rk,
                 code1=code1, code2=code2,
                 reach=reach,
                 status=status
@@ -159,10 +168,10 @@ class ProfileXYZ(Profile, SQLSubModel):
         sql = (
             "INSERT OR REPLACE INTO " +
             "geometry_profileXYZ(id, ind, name, reach, " +
-            "kp, num, code1, code2, sl) " +
+            "rk, num, code1, code2, sl) " +
             "VALUES (" +
             f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
-            f"{self.reach.id}, {self.kp}, {self.num}, " +
+            f"{self.reach.id}, {self.rk}, {self.num}, " +
             f"{self.code1}, {self.code1}, {sl}" +
             ")"
         )
@@ -187,19 +196,19 @@ class ProfileXYZ(Profile, SQLSubModel):
         try:
             if len(header) == 0:
                 name = data[0]
-                kp = data[1]
+                rk = data[1]
                 reach = data[2]
                 status = data[3]
 
                 profile = cls(
                     id=-1,
                     name=name,
-                    kp=kp,
+                    rk=rk,
                     reach=reach,
                     status=status
                 )
             else:
-                valid_header = {'name', 'reach', 'kp', 'status'}
+                valid_header = {'name', 'reach', 'rk', 'status'}
                 d = {}
                 for i, v in enumerate(data):
                     h = header[i].strip().lower().split(' ')[0]
@@ -323,7 +332,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             logger.debug(f"{e}")
             raise IndexError(
                 f"Invalid point name: {name} " +
-                f"for profile ({self.id}) kp = {self.kp}"
+                f"for profile ({self.id}) rk = {self.rk}"
             )
 
     def has_standard_named_points(self):

src/Model/Geometry/Reach.py

@@ -141,10 +141,10 @@ class Reach(SQLSubModel):
     def profiles(self, profiles):
         self._profiles = profiles
 
-    def get_profiles_from_kp(self, kp):
+    def get_profiles_from_rk(self, rk):
         return list(
             filter(
-                lambda p: p.kp == kp, self.profiles
+                lambda p: p.rk == rk, self.profiles
             )
         )
 
@@ -335,18 +335,18 @@ class Reach(SQLSubModel):
             )
         )
 
-    def get_kp(self):
+    def get_rk(self):
-        """List of profiles kp
+        """List of profiles rk
 
         Returns:
-            List of profiles kp
+            List of profiles rk
         """
-        return [profile.kp for profile in self.profiles]
+        return [profile.rk for profile in self.profiles]
 
-    def get_kp_complete_profiles(self):
+    def get_rk_complete_profiles(self):
         return list(
             map(
-                lambda profile: profile.kp,
+                lambda profile: profile.rk,
                 filter(
                     lambda profile: len(profile) > 0,
                     self.profiles
@@ -354,41 +354,41 @@ class Reach(SQLSubModel):
             )
         )
 
-    def get_kp_min(self):
+    def get_rk_min(self):
-        if len(self.get_kp()) > 0:
+        if len(self.get_rk()) > 0:
-            return min(self.get_kp())
+            return min(self.get_rk())
         else:
             return 0.0
 
-    def get_kp_max(self):
+    def get_rk_max(self):
-        if len(self.get_kp()) > 0:
+        if len(self.get_rk()) > 0:
-            return max(self.get_kp())
+            return max(self.get_rk())
         else:
             return 0.0
 
-    def inter_profiles_kp(self):
+    def inter_profiles_rk(self):
-        profiles = sorted(self.profiles, key=lambda p: p.kp)
+        profiles = sorted(self.profiles, key=lambda p: p.rk)
         first = profiles[0]
         last = profiles[-1]
 
-        res_kp = [first.kp]
+        res_rk = [first.rk]
 
         profiles = iter(profiles)
         previous = next(profiles)
 
         for profile in profiles:
-            prev = previous.kp
+            prev = previous.rk
-            curr = profile.kp
+            curr = profile.rk
 
-            diff = abs(previous.kp - profile.kp)
+            diff = abs(previous.rk - profile.rk)
 
-            new = previous.kp + (diff / 2.0)
+            new = previous.rk + (diff / 2.0)
-            res_kp.append(new)
+            res_rk.append(new)
 
             previous = profile
 
-        res_kp.append(last.kp)
+        res_rk.append(last.rk)
-        return res_kp
+        return res_rk
 
     # Sediment Layers
 
@@ -536,7 +536,7 @@ class Reach(SQLSubModel):
     def sort(self, is_reversed: bool = False):
         self.profiles = sorted(
             self.profiles,
-            key=lambda profile: profile.kp,
+            key=lambda profile: profile.rk,
             reverse=is_reversed
         )
         self._status.modified()
@@ -613,7 +613,7 @@ class Reach(SQLSubModel):
 
         self.profiles = profiles + self.profiles
         self._update_profile_numbers()
-        self._recompute_kp()
+        self._recompute_rk()
 
         return profiles
 
@@ -633,7 +633,7 @@ class Reach(SQLSubModel):
         try:
             list_profile, list_header = self.read_file_st(str(file_path_name))
             profile_header = ["num", "code1",
-                              "code2", "nb_point", "kp", "name"]
+                              "code2", "nb_point", "rk", "name"]
 
             if list_profile and list_header:
                 for ind, profile in enumerate(list_profile):
@@ -721,12 +721,12 @@ class Reach(SQLSubModel):
                 c1 = f"{profile.code1:>6}"
                 c2 = f"{profile.code2:>6}"
                 t = f"{len(profile.points):>6}"
-                kp = f"{profile.kp:>12f}"[0:12]
+                rk = f"{profile.rk:>12f}"[0:12]
                 pname = profile.name
                 if profile.name == "":
                     pname = f"p{profile.id:>3}".replace(" ", "0")
 
-                st.write(f"{num}{c1}{c2}{t} {kp} {pname}\n")
+                st.write(f"{num}{c1}{c2}{t} {rk} {pname}\n")
 
                 for point in profile.points:
                     x = f"{point.x:<12.4f}"[0:12]
@@ -745,15 +745,15 @@ class Reach(SQLSubModel):
         last = self.profile(len(self) - 1)
 
         z_first = first.z_min()
-        kp_first = first.kp
+        rk_first = first.rk
 
         z_last = last.z_min()
-        kp_last = last.kp
+        rk_last = last.rk
 
         return (
             (z_last - z_first)
             /
-            (kp_last - kp_first)
+            (rk_last - rk_first)
         )
 
     def get_incline_mean(self):
@@ -764,15 +764,15 @@ class Reach(SQLSubModel):
 
         for profile in profiles[1:]:
             z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk
 
             z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk
 
             incline_acc += (
                 (z_last - z_first)
                 /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
             )
 
             previous = profile
@@ -787,15 +787,15 @@ class Reach(SQLSubModel):
 
         for profile in profiles[1:]:
             z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk
 
             z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk
 
             incline_acc += [
                 (z_last - z_first)
                 /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
             ]
 
             previous = profile
@@ -811,15 +811,15 @@ class Reach(SQLSubModel):
 
         for profile in profiles[1:]:
             z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk
 
             z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk
 
             incline_acc += [
                 (z_last - z_first)
                 /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
             ]
 
             previous = profile
@@ -847,14 +847,14 @@ class Reach(SQLSubModel):
             logger_exception(e)
             return 0
 
-    def _recompute_kp(self, offset=0.0):
+    def _recompute_rk(self, offset=0.0):
-        self._recompute_kp_no_gl(offset=offset)
+        self._recompute_rk_no_gl(offset=offset)
 
-    def _recompute_kp_no_gl(self, offset=0.0):
+    def _recompute_rk_no_gl(self, offset=0.0):
         profiles = iter(self.profiles)
 
         previous = next(profiles)
-        previous.kp = offset
+        previous.rk = offset
 
         for profile in profiles:
             prev_points = previous.points
@@ -865,5 +865,5 @@ class Reach(SQLSubModel):
                 prev_points[-1].dist_2d(curr_points[-1])
             ) / 2.0
 
-            profile.kp = previous.kp + dist
+            profile.rk = previous.rk + dist
             previous = profile

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -50,8 +50,8 @@ class HydraulicStructure(SQLSubModel):
             self.id = id
 
         self._name = name
-        self._input_kp = None
+        self._input_rk = None
-        self._output_kp = None
+        self._output_rk = None
         self._input_reach = None
         self._output_reach = None
         self._enabled = True
@@ -69,8 +69,8 @@ class HydraulicStructure(SQLSubModel):
             id INTEGER NOT NULL PRIMARY KEY,
             name TEXT NOT NULL,
             enabled BOOLEAN NOT NULL,
-            input_kp REAL NOT NULL,
+            input_rk REAL NOT NULL,
-            output_kp REAL NOT NULL,
+            output_rk REAL NOT NULL,
             input_reach INTEGER,
             output_reach INTEGER,
             FOREIGN KEY(input_reach) REFERENCES river_reach(id),
@@ -84,9 +84,25 @@ class HydraulicStructure(SQLSubModel):
     def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
-            if int(release) < 6:
+            rl = int(release)
+
+            if rl < 6:
                 cls._db_create(execute)
 
+            if rl < 11:
+                execute(
+                    """
+                    ALTER TABLE hydraulic_structures
+                    RENAME COLUMN input_kp TO input_rk
+                    """
+                )
+                execute(
+                    """
+                    ALTER TABLE hydraulic_structures
+                    RENAME COLUMN output_kp TO output_rk
+                    """
+                )
+
         return True
 
     @classmethod
@@ -95,7 +111,7 @@ class HydraulicStructure(SQLSubModel):
 
         table = execute(
             "SELECT id, name, enabled, " +
-            "input_kp, output_kp, " +
+            "input_rk, output_rk, " +
             "input_reach, output_reach " +
             "FROM hydraulic_structures "
         )
@@ -106,8 +122,8 @@ class HydraulicStructure(SQLSubModel):
             hs_id = next(it)
             name = next(it)
             enabled = (next(it) == 1)
-            input_kp = next(it)
+            input_rk = next(it)
-            output_kp = next(it)
+            output_rk = next(it)
             input_reach_id = next(it)
             output_reach_id = next(it)
 
@@ -118,8 +134,8 @@ class HydraulicStructure(SQLSubModel):
             )
 
             hs.enabled = enabled
-            hs.input_kp = input_kp if input_kp != -1 else None
+            hs.input_rk = input_rk if input_rk != -1 else None
-            hs.output_kp = output_kp if output_kp != -1 else None
+            hs.output_rk = output_rk if output_rk != -1 else None
 
             hs.input_reach, hs.output_reach = reduce(
                 lambda acc, n: (
@@ -148,24 +164,24 @@ class HydraulicStructure(SQLSubModel):
         if self._output_reach is not None:
             output_reach_id = self._output_reach.id
 
-        input_kp = -1
+        input_rk = -1
-        if self.input_kp is not None:
+        if self.input_rk is not None:
-            input_kp = self.input_kp
+            input_rk = self.input_rk
 
-        output_kp = -1
+        output_rk = -1
-        if self.output_kp is not None:
+        if self.output_rk is not None:
-            output_kp = self.output_kp
+            output_rk = self.output_rk
 
         sql = (
             "INSERT INTO " +
             "hydraulic_structures(" +
-            "  id, name, enabled, input_kp, output_kp, " +
+            "  id, name, enabled, input_rk, output_rk, " +
             "  input_reach, output_reach" +
             ") " +
             "VALUES (" +
             f"{self.id}, '{self._db_format(self._name)}', " +
             f"{self._db_format(self.enabled)}, " +
-            f"{input_kp}, {output_kp}, " +
+            f"{input_rk}, {output_rk}, " +
             f"{input_reach_id}, {output_reach_id}" +
             ")"
         )
@@ -198,24 +214,24 @@ class HydraulicStructure(SQLSubModel):
         self._status.modified()
 
     @property
-    def input_kp(self):
+    def input_rk(self):
-        return self._input_kp
+        return self._input_rk
 
-    @input_kp.setter
+    @input_rk.setter
-    def input_kp(self, input_kp):
+    def input_rk(self, input_rk):
-        if input_kp is not None:
+        if input_rk is not None:
-            input_kp = float(input_kp)
+            input_rk = float(input_rk)
 
-        self._input_kp = input_kp
+        self._input_rk = input_rk
         self._status.modified()
 
     @property
-    def output_kp(self):
+    def output_rk(self):
-        return self._output_kp
+        return self._output_rk
 
-    @output_kp.setter
+    @output_rk.setter
-    def output_kp(self, output_kp):
+    def output_rk(self, output_rk):
-        self._output_kp = output_kp
+        self._output_rk = output_rk
         self._status.modified()
 
     @property

src/Model/InitialConditions/InitialConditions.py

@@ -30,7 +30,7 @@ logger = logging.getLogger()
 class Data(SQLSubModel):
     def __init__(self, name: str = "",
                  comment: str = "", reach=None,
-                 kp: float = 0.0, discharge: float = 0.0,
+                 rk: float = 0.0, discharge: float = 0.0,
                  height: float = 0.0,
                  status=None):
         super(Data, self).__init__()
@@ -42,14 +42,14 @@ class Data(SQLSubModel):
         self._name = name
         self._comment = comment
 
-        self._kp = kp
+        self._rk = rk
         self._discharge = discharge
         self._speed = 0.0
         self._elevation = 0.0
         self._height = height
 
-        if self._kp != 0.0:
+        if self._rk != 0.0:
-            self._update_from_kp()
+            self._update_from_rk()
         if self._height != 0.0:
             self._update_from_height()
         if self._discharge != 0.0:
@@ -64,7 +64,7 @@ class Data(SQLSubModel):
             name TEXT NOT NULL,
             comment TEXT NOT NULL,
             reach INTEGER,
-            kp REAL NOT NULL,
+            rk REAL NOT NULL,
             discharge REAL NOT NULL,
             height REAL NOT NULL,
             FOREIGN KEY(reach) REFERENCES river_reach(id)
@@ -75,13 +75,20 @@ class Data(SQLSubModel):
 
     @classmethod
     def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute(
+                    "ALTER TABLE initial_conditions RENAME COLUMN kp TO rk"
+                )
+
         return cls._update_submodel(execute, version)
 
     @classmethod
     def _db_load(cls, execute, data=None):
         id = data["reach"].id
         table = execute(
-            "SELECT ind, name, comment, kp, discharge, height " +
+            "SELECT ind, name, comment, rk, discharge, height " +
             "FROM initial_conditions " +
             f"WHERE reach = {id}"
         )
@@ -95,7 +102,7 @@ class Data(SQLSubModel):
             ind = row[0]
             name = row[1]
             comment = row[2]
-            kp = row[3]
+            rk = row[3]
             discharge = row[4]
             height = row[5]
 
@@ -104,7 +111,7 @@ class Data(SQLSubModel):
                 status=data["status"],
                 name=name,
                 comment=comment,
-                kp=kp,
+                rk=rk,
                 discharge=discharge,
                 height=height,
             )
@@ -118,12 +125,12 @@ class Data(SQLSubModel):
 
         execute(
             "INSERT INTO " +
-            "initial_conditions(ind, name, comment, kp, " +
+            "initial_conditions(ind, name, comment, rk, " +
             "discharge, height, reach) " +
             "VALUES (" +
             f"{ind}, '{self._db_format(self.name)}', " +
             f"'{self._db_format(self._comment)}', " +
-            f"{self._kp}, {self._discharge}, {self._height}, " +
+            f"{self._rk}, {self._discharge}, {self._height}, " +
             f"{self._reach.id}" +
             ")"
         )
@@ -134,7 +141,7 @@ class Data(SQLSubModel):
         new = Data(
             name=self.name,
             comment=self._comment,
-            kp=self._kp,
+            rk=self._rk,
             discharge=self._discharge,
             height=self._height,
             reach=self._reach,
@@ -154,8 +161,8 @@ class Data(SQLSubModel):
             val = self._name
         elif key == "comment":
             val = self._comment
-        elif key == "kp":
+        elif key == "rk":
-            val = self._kp
+            val = self._rk
         elif key == "speed":
             val = self._speed
         elif key == "discharge":
@@ -168,7 +175,7 @@ class Data(SQLSubModel):
         return val
 
     def _update_get_min(self):
-        profile = self._reach.reach.get_profiles_from_kp(self._kp)
+        profile = self._reach.reach.get_profiles_from_rk(self._rk)
         if len(profile) > 0:
             min = profile[0].z_min()
         else:
@@ -176,7 +183,7 @@ class Data(SQLSubModel):
 
         return min
 
-    def _update_from_kp(self):
+    def _update_from_rk(self):
         min = self._update_get_min()
         self._elevation = min + self._height
 
@@ -197,9 +204,9 @@ class Data(SQLSubModel):
             self._name = str(value)
         elif key == "comment":
             self._comment = str(value)
-        elif key == "kp":
+        elif key == "rk":
-            self._kp = float(value)
+            self._rk = float(value)
-            self._update_from_kp()
+            self._update_from_rk()
         elif key == "speed":
             # Not supposed to be modified
             self._speed = float(value)
@@ -298,10 +305,10 @@ class InitialConditions(SQLSubModel):
         self._data.insert(index, n)
         self._status.modified()
 
-    def new_from_data(self, kp, discharge, elevation):
+    def new_from_data(self, rk, discharge, elevation):
         n = Data(reach=self._reach, status=self._status)
 
-        n['kp'] = kp
+        n['rk'] = rk
         n['discharge'] = discharge
         n['elevation'] = elevation
 
@@ -344,8 +351,8 @@ class InitialConditions(SQLSubModel):
             )
         )
 
-    def get_kp(self):
+    def get_rk(self):
-        return self._data_get("kp")
+        return self._data_get("rk")
 
     def get_elevation(self):
         return self._data_get("elevation")
@@ -353,10 +360,10 @@ class InitialConditions(SQLSubModel):
     def get_discharge(self):
         return self._data_get("discharge")
 
-    def _sort_by_z_and_kp(self, profiles):
+    def _sort_by_z_and_rk(self, profiles):
         profiles.sort(
             reverse=False,
-            key=lambda p: p.kp
+            key=lambda p: p.rk
         )
 
         first_z = profiles[0].z()
@@ -365,14 +372,14 @@ class InitialConditions(SQLSubModel):
         if first_z > last_z:
             profiles.sort(
                 reverse=True,
-                key=lambda p: p.kp
+                key=lambda p: p.rk
             )
 
     def generate_growing_constante_height(self, height: float):
         self._data = []
 
         profiles = self._reach.reach.profiles.copy()
-        self._sort_by_z_and_kp(profiles)
+        self._sort_by_z_and_rk(profiles)
 
         incline = self._reach.reach.get_incline_median_mean()
         logger.debug(f"incline = {incline}")
@@ -393,13 +400,13 @@ class InitialConditions(SQLSubModel):
                 previous_elevation
             )
 
-            logger.debug(f"({profile.kp}):")
+            logger.debug(f"({profile.rk}):")
             logger.debug(f"  width  = {width}")
             logger.debug(f"  strickler = {strickler}")
             logger.debug(f"  discharge = {discharge}")
 
             new = Data(reach=self._reach, status=self._status)
-            new["kp"] = profile.kp
+            new["rk"] = profile.rk
             new["discharge"] = discharge
 
             new["elevation"] = elevation
@@ -418,7 +425,7 @@ class InitialConditions(SQLSubModel):
 
     def _generate_height_estimation_from_discharge(self, discharge: float):
         profiles = self._reach.reach.profiles.copy()
-        self._sort_by_z_and_kp(profiles)
+        self._sort_by_z_and_rk(profiles)
 
         previous_elevation = -99999.99
 
@@ -439,13 +446,13 @@ class InitialConditions(SQLSubModel):
                 previous_elevation
             )
 
-            logger.debug(f"({profile.kp}):")
+            logger.debug(f"({profile.rk}):")
             logger.debug(f"  width  = {width}")
             logger.debug(f"  strickler = {strickler}")
             logger.debug(f"  height = {height}")
 
             new = Data(reach=self._reach, status=self._status)
-            new["kp"] = profile.kp
+            new["rk"] = profile.rk
             new["discharge"] = discharge
             new["elevation"] = elevation
 
@@ -456,10 +463,10 @@ class InitialConditions(SQLSubModel):
 
     def _generate_resort_data(self, profiles):
         is_reverse = False
-        if profiles[0].kp > profiles[-1].kp:
+        if profiles[0].rk > profiles[-1].rk:
             is_reverse = True
 
         self._data.sort(
             reverse=not is_reverse,
-            key=lambda d: d['kp']
+            key=lambda d: d['rk']
         )

src/Model/LateralContribution/LateralContribution.py

@@ -48,8 +48,8 @@ class LateralContribution(SQLSubModel):
         self._name = name
         self._type = ""
         self._edge = None
-        self._begin_kp = 0.0
+        self._begin_rk = 0.0
-        self._end_kp = 0.0
+        self._end_rk = 0.0
         self._data = []
         self._header = []
         self._types = [float, float]
@@ -66,8 +66,8 @@ class LateralContribution(SQLSubModel):
             type TEXT NOT NULL,
             tab TEXT NOT NULL,
             edge INTEGER,
-            begin_kp REAL NOT NULL,
+            begin_rk REAL NOT NULL,
-            end_kp REAL NOT NULL,
+            end_rk REAL NOT NULL,
             FOREIGN KEY(edge) REFERENCES river_reach(id)
           )
         """)
@@ -87,6 +87,22 @@ class LateralContribution(SQLSubModel):
 
     @classmethod
     def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute(
+                    """
+                    ALTER TABLE lateral_contribution
+                    RENAME COLUMN begin_kp TO begin_rk
+                    """
+                )
+                execute(
+                    """
+                    ALTER TABLE lateral_contribution
+                    RENAME COLUMN end_kp TO end_rk
+                    """
+                )
+
         return True
 
     @classmethod
@@ -110,7 +126,7 @@ class LateralContribution(SQLSubModel):
         tab = data["tab"]
 
         table = execute(
-            "SELECT id, name, type, edge, begin_kp, end_kp " +
+            "SELECT id, name, type, edge, begin_rk, end_rk " +
             f"FROM lateral_contribution WHERE tab = '{tab}'"
         )
 
@@ -125,8 +141,8 @@ class LateralContribution(SQLSubModel):
             lc.edge = None
             if row[3] != -1:
                 lc.edge = next(filter(lambda e: e.id == row[3], data["edges"]))
-            lc._begin_kp = row[4]
+            lc._begin_rk = row[4]
-            lc._end_kp = row[5]
+            lc._end_rk = row[5]
 
             values = execute(
                 "SELECT ind, data0, data1 FROM lateral_contribution_data " +
@@ -160,11 +176,11 @@ class LateralContribution(SQLSubModel):
         sql = (
             "INSERT INTO " +
             "lateral_contribution(id, name, type, tab, " +
-            "edge, begin_kp, end_kp) " +
+            "edge, begin_rk, end_rk) " +
             "VALUES (" +
             f"{self.id}, '{self._db_format(self._name)}', " +
             f"'{self._db_format(self._type)}', '{tab}', {edge}, " +
-            f"{self._begin_kp}, {self._end_kp}" +
+            f"{self._begin_rk}, {self._end_rk}" +
             ")"
         )
         execute(sql)
@@ -231,44 +247,44 @@ class LateralContribution(SQLSubModel):
     def edge(self, edge):
         self._edge = edge
         if edge is not None:
-            self._begin_kp = self._edge.reach.get_kp_min()
+            self._begin_rk = self._edge.reach.get_rk_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            self._end_rk = self._edge.reach.get_rk_max()
         self._status.modified()
 
     def has_edge(self):
         return self._edge is not None
 
     @property
-    def begin_kp(self):
+    def begin_rk(self):
-        return self._begin_kp
+        return self._begin_rk
 
-    @begin_kp.setter
+    @begin_rk.setter
-    def begin_kp(self, begin_kp):
+    def begin_rk(self, begin_rk):
         if self._edge is None:
-            self._begin_kp = begin_kp
+            self._begin_rk = begin_rk
         else:
-            _min = self._edge.reach.get_kp_min()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= begin_kp <= _max:
+            if _min <= begin_rk <= _max:
-                self._begin_kp = begin_kp
+                self._begin_rk = begin_rk
 
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
         if self._edge is None:
-            self._end_kp = end_kp
+            self._end_rk = end_rk
         else:
-            _min = self._edge.reach.get_kp_min()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= end_kp <= _max:
+            if _min <= end_rk <= _max:
-                self._end_kp = end_kp
+                self._end_rk = end_rk
 
         self._status.modified()
 
@@ -377,8 +393,8 @@ class LateralContribution(SQLSubModel):
     def convert(self, cls):
         new = cls(name=self.name, status=self._status)
         new.edge = self.edge
-        new.begin_kp = self.begin_kp
+        new.begin_rk = self.begin_rk
-        new.end_kp = self.end_kp
+        new.end_rk = self.end_rk
 
         for i, _ in enumerate(self.data):
             new.add(i)

src/Model/Results/River/River.py

@@ -35,8 +35,8 @@ class Profile(object):
         return self._profile.name
 
     @property
-    def kp(self):
+    def rk(self):
-        return self._profile.kp
+        return self._profile.rk
 
     @property
     def geometry(self):

src/Model/Saved.py

@@ -22,10 +22,19 @@ logger = logging.getLogger()
 
 
 class SavedStatus(object):
-    def __init__(self):
+    def __init__(self, version=0):
         super(SavedStatus, self).__init__()
+        self._version = version
         self._saved = True
 
+    @property
+    def version(self):
+        return self._version
+
+    @version.setter
+    def version(self, version):
+        self._version = version
+
     def is_saved(self):
         return self._saved
 
@@ -34,5 +43,11 @@ class SavedStatus(object):
         self._saved = True
 
     def modified(self):
-        # logger.debug("model status set as modified")
+        if self._saved:
+            self._version += 1
+
+        logger.debug(
+            "STATUS: Model status set as modified " +
+            f"at version {self._version}"
+        )
         self._saved = False

src/Model/Study.py

@@ -41,7 +41,7 @@ class Study(SQLModel):
 
     def __init__(self, filename=None, init_new=True):
         # Metadata
-        self._version = "0.0.9"
+        self._version = "0.0.11"
         self.creation_date = datetime.now()
         self.last_modification_date = datetime.now()
         self.last_save_date = datetime.now()
@@ -117,6 +117,9 @@ class Study(SQLModel):
         if ".backup" in self.filename:
             is_new = True
 
+        if not os.path.exists(self.filename):
+            is_new = True
+
         self._init_db_file(self.filename, is_new=is_new)
         self.commit()
 
@@ -209,7 +212,12 @@ class Study(SQLModel):
     def _create(self):
         # Info (metadata)
         self.execute(
-            "CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
+            "INSERT INTO info VALUES ('study_release', '0')"
+        )
+
+        self.execute(
+            "CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)"
+        )
         self.execute(
             "INSERT INTO info VALUES ('version', " +
             f"'{self._db_format(self._version)}')",
@@ -218,19 +226,20 @@ class Study(SQLModel):
         self.execute("INSERT INTO info VALUES ('name', '')")
         self.execute("INSERT INTO info VALUES ('description', '')")
         self.execute(
-            f"INSERT INTO info VALUES ('time_system', '{self._time_system}')")
+            f"INSERT INTO info VALUES ('time_system', '{self._time_system}')"
+        )
         self.execute(
-            f"INSERT INTO info VALUES ('date', " +
+            "INSERT INTO info VALUES ('date', " +
-            "'{self._date.timestamp()}')"
+            f"'{self._date.timestamp()}')"
         )
 
         self.execute(
-            f"INSERT INTO info VALUES ('creation_date', " +
+            "INSERT INTO info VALUES ('creation_date', " +
-            "'{self.creation_time.timestamp()}')"
+            f"'{self.creation_date.timestamp()}')"
         )
         self.execute(
-            f"INSERT INTO info VALUES ('last_save_date', " +
+            "INSERT INTO info VALUES ('last_save_date', " +
-            "'{self.last_save_time.timestamp()}')"
+            f"'{self.last_save_date.timestamp()}')"
         )
 
         self._create_submodel()
@@ -245,6 +254,12 @@ class Study(SQLModel):
 
         logger.debug("Update database")
 
+        major, minor, release = version[0].split('.')
+        if major == "0" and minor == "0" and int(release) < 10:
+            self.execute(
+                "INSERT INTO info VALUES ('study_release', '0')"
+            )
+
         if self._update_submodel(version[0]):
             self.execute(
                 f"UPDATE info SET value='{self._version}' WHERE key='version'"
@@ -258,6 +273,11 @@ class Study(SQLModel):
     def _load(cls, filename):
         new = cls(init_new=False, filename=filename)
 
+        version = new.execute(
+            "SELECT value FROM info WHERE key='study_release'"
+        )
+        new.status.version = int(version[0])
+
         # TODO: Load metadata
         new.name = new.execute("SELECT value FROM info WHERE key='name'")[0]
         new.description = new.execute(
@@ -292,6 +312,11 @@ class Study(SQLModel):
     def _save(self, progress=None):
         progress = progress if progress is not None else lambda: None
 
+        self.execute(
+            "INSERT INTO info VALUES ('study_release', " +
+            f"'{self.status.version}')"
+        )
+
         self.execute(
             f"UPDATE info SET " +
             f"value='{self._db_format(self.name)}' WHERE key='name'"

src/Solver/Mage.py

@@ -180,7 +180,7 @@ class Mage(CommandLineSolver):
         c1 = f"{profile.code1:>6}"
         c2 = f"{profile.code2:>6}"
         t = f"{len(profile.points):>6}"
-        kp = f"{profile.kp:>12f}"[0:12]
+        rk = f"{profile.rk:>12f}"[0:12]
         pname = profile.name
         if profile.name == "":
             # Generate name from profile id prefixed with
@@ -207,7 +207,7 @@ class Mage(CommandLineSolver):
                 )
 
         # Profile header line
-        wfile.write(f"{num}{c1}{c2}{t} {kp} {pname} {sediment}\n")
+        wfile.write(f"{num}{c1}{c2}{t} {rk} {pname} {sediment}\n")
 
     def _export_ST_point_line(self, wfile, files, point):
         x = f"{point.x:<12.4f}"[0:12]
@@ -339,7 +339,7 @@ class Mage(CommandLineSolver):
         f.write(f"* {lateral.edge.name} ({name}) {lateral.lctype}\n")
         f.write(
             f"${name}    " +
-            f"{lateral.begin_kp:>10.4f} {lateral.end_kp:>10.4f}\n"
+            f"{lateral.begin_rk:>10.4f} {lateral.end_rk:>10.4f}\n"
         )
         header = lateral.header
         f.write(f"*{header[0]:>9}|{header[1]:>10}\n")
@@ -371,17 +371,17 @@ class Mage(CommandLineSolver):
                         continue
 
                     num = f"{id:>3}"
-                    bkp = f"{friction.begin_kp:>10.3f}"
+                    brk = f"{friction.begin_rk:>10.3f}"
-                    ekp = f"{friction.end_kp:>10.3f}"
+                    erk = f"{friction.end_rk:>10.3f}"
 
-                    # if friction.begin_kp != friction.end_kp:
+                    # if friction.begin_rk != friction.end_rk:
                     #     print("TODO")
 
                     strickler = friction.begin_strickler
                     coef_1 = f"{strickler.minor:>10.3f}"
                     coef_2 = f"{strickler.medium:>10.3f}"
 
-                    f.write(f"K{num}      {bkp}{ekp}{coef_1}{coef_2}\n")
+                    f.write(f"K{num}      {brk}{erk}{coef_1}{coef_2}\n")
 
                 id += 1
 
@@ -401,7 +401,7 @@ class Mage(CommandLineSolver):
 
             # TODO put real date...
             f.write(f"$ date en minutes :       0.00\n")
-            f.write(f"* IB IS    discharge  elevation         kp\n")
+            f.write(f"* IB IS    discharge  elevation         rk\n")
 
             id = 1
             for reach in reachs:
@@ -418,9 +418,9 @@ class Mage(CommandLineSolver):
                     IS = f"{id_sec}"
                     discharge = f"{d['discharge']:>10.5f}"
                     elevation = f"{d['elevation']:>11.6f}"
-                    kp = f"{d['kp']:>9.2f}"
+                    rk = f"{d['rk']:>9.2f}"
 
-                    f.write(f"{IR} {IS} {discharge} {elevation} {kp}\n")
+                    f.write(f"{IR} {IS} {discharge} {elevation} {rk}\n")
                     id_sec += 1
 
                 id += 1
@@ -495,12 +495,12 @@ class Mage(CommandLineSolver):
                 if not hs.enabled:
                     continue
 
-                if hs.input_kp is None:
+                if hs.input_rk is None:
                     continue
 
                 f.write(
                     '* ouvrage au pk ' +
-                    f"{float(hs.input_kp):>12.1f}" + ' ' +
+                    f"{float(hs.input_rk):>12.1f}" + ' ' +
                     hs.name + '\n'
                 )
 
@@ -527,7 +527,7 @@ class Mage(CommandLineSolver):
 
                 f.write(
                     f"{sin_dict[bhs._type]} " +
-                    f"{reach_id} {float(hs.input_kp):>12.3f} " +
+                    f"{reach_id} {float(hs.input_rk):>12.3f} " +
                     f"{param_str} {name}\n"
                 )
 

src/Solver/RubarBE.py

@@ -265,10 +265,10 @@ class RubarBE(CommandLineSolver):
 
                 ind = 1
                 for profile in reach.profiles:
-                    kp = profile.kp
+                    rk = profile.rk
                     n_points = len(profile)
 
-                    f.write(f"{ind:>4} {kp:>11.3f} {n_points:>4}\n")
+                    f.write(f"{ind:>4} {rk:>11.3f} {n_points:>4}\n")
 
                     for point in profile.points:
                         label = point.name.lower()
@@ -307,8 +307,8 @@ class RubarBE(CommandLineSolver):
                 lm = len(reach) + 1
                 f.write(f"{lm:>13}\n")
 
-                for mails in [reach.inter_profiles_kp(),
+                for mails in [reach.inter_profiles_rk(),
-                              reach.get_kp()]:
+                              reach.get_rk()]:
                     ind = 0
                     for mail in mails:
                         f.write(f"{mail:15.3f}")
@@ -338,7 +338,7 @@ class RubarBE(CommandLineSolver):
                 lm = len(reach) + 1
                 f.write(f"{lm:>6}\n")
 
-                def get_stricklers_from_kp(kp):
+                def get_stricklers_from_rk(rk):
                     return next(
                         map(
                             lambda s: (
@@ -346,15 +346,15 @@ class RubarBE(CommandLineSolver):
                                 else s.begin_strickler.minor
                             ),
                             filter(
-                                lambda f: kp in f,
+                                lambda f: rk in f,
                                 edge.frictions.lst
                             )
                         )
                     )
 
                 ind = 1
-                for mail in edge.reach.inter_profiles_kp():
+                for mail in edge.reach.inter_profiles_rk():
-                    coef = get_stricklers_from_kp(mail)
+                    coef = get_stricklers_from_rk(mail)
 
                     f.write(f"{ind:>6} {coef:>12.5f}")
 
@@ -382,7 +382,7 @@ class RubarBE(CommandLineSolver):
                 first = profiles[0]
                 last = profiles[-1]
 
-                if first.kp not in data or last.kp not in data:
+                if first.rk not in data or last.rk not in data:
                     logger.error(
                         "Study initial condition is not fully defined"
                     )
@@ -400,7 +400,7 @@ class RubarBE(CommandLineSolver):
 
                 prev_h, prev_s = f_h_s
                 for profile in it:
-                    if profile.kp not in data:
+                    if profile.rk not in data:
                         ind += 1
                         continue
 
@@ -424,7 +424,7 @@ class RubarBE(CommandLineSolver):
         data = {}
 
         for d in ics.data:
-            data[d['kp']] = (
+            data[d['rk']] = (
                 d['elevation'],
                 d['discharge'],
             )
@@ -432,8 +432,8 @@ class RubarBE(CommandLineSolver):
         return data
 
     def _export_tps_profile_height_speed(self, profile, data):
-        z = data[profile.kp][0]
+        z = data[profile.rk][0]
-        q = data[profile.kp][1]
+        q = data[profile.rk][1]
 
         height = z - profile.z_min()
         speed = profile.speed(q, z)

src/View/BoundaryCondition/Edit/Table.py

@@ -99,7 +99,7 @@ class TableModel(PamhyrTableModel):
             logger.info(e)
             logger.debug(traceback.format_exc())
 
-        self.dataChanged.emit(index, index)
+        self.update()
         return True
 
     def add(self, row, parent=QModelIndex()):
@@ -112,7 +112,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endInsertRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def delete(self, rows, parent=QModelIndex()):
         self.beginRemoveRows(parent, rows[0], rows[-1])
@@ -135,7 +135,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.layoutAboutToBeChanged.emit()
-        self.layoutChanged.emit()
+        self.update()
 
     def move_up(self, row, parent=QModelIndex()):
         if row <= 0:
@@ -152,7 +152,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def move_down(self, index, parent=QModelIndex()):
         if row > len(self._data):
@@ -169,7 +169,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def paste(self, row, header, data):
         if len(data) == 0:
@@ -190,4 +190,13 @@ class TableModel(PamhyrTableModel):
         )
 
         self.layoutAboutToBeChanged.emit()
+        self.update()
+
+    def auto_sort(self):
+        self.layoutAboutToBeChanged.emit()
+        self._data.sort(key=lambda x: x[0])
+        self.layoutAboutToBeChanged.emit()
+
+    def update(self):
+        # self.auto_sort()
         self.layoutChanged.emit()

src/View/BoundaryCondition/Edit/Window.py

@@ -195,6 +195,7 @@ class EditBoundaryConditionWindow(PamhyrWindow):
         self.find(QAction, "action_sort").triggered.connect(self.sort)
 
         self._table.dataChanged.connect(self.update)
+        self._table.layoutChanged.connect(self.update)
 
         if self._is_solid:
             self._d50sigma.d50Changed.connect(self.d50_changed)

src/View/Frictions/PlotRKZ.py

@@ -0,0 +1,50 @@
+# PlotRKC.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+from View.HydraulicStructures.PlotRKC import PlotRKC
+
+_translate = QCoreApplication.translate
+
+
+class PlotRKZ(PlotRKC):
+    def __init__(self, canvas=None, trad=None, toolbar=None,
+                 river=None, reach=None, profile=None,
+                 parent=None):
+        super(PlotRKC, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=river,
+            toolbar=toolbar,
+            parent=parent
+        )
+
+        self._current_reach = reach
+        self._current_profile = profile
+
+        self.label_x = self._trad["unit_rk"]
+        self.label_y = self._trad["unit_elevation"]
+
+        self._isometric_axis = False
+
+        self._auto_relim_update = True
+        self._autoscale_update = True
+        self.parent = parent
+
+    def onpick(self, event):
+        return

src/View/Frictions/PlotStricklers.py

@@ -41,10 +41,10 @@ class PlotStricklers(PamhyrPlot):
             parent=parent
         )
 
-        self.label_x = self._trad["kp"]
+        self.label_x = self._trad["rk"]
         self.label_y = self._trad["strickler_plot"]
 
-        self.line_kp_elevation = [None, None]
+        self.line_rk_elevation = [None, None]
 
         self._isometric_axis = False
 
@@ -65,9 +65,9 @@ class PlotStricklers(PamhyrPlot):
         self._init = True
 
     def draw_data(self):
-        kp = self.data.reach.get_kp()
+        rk = self.data.reach.get_rk()
         self.canvas.axes.set_xlim(
-            left=min(kp), right=max(kp)
+            left=min(rk), right=max(rk)
         )
 
         frictions = self.data.frictions
@@ -76,14 +76,14 @@ class PlotStricklers(PamhyrPlot):
             self.draw_frictions(lst, self.color_plot)
 
             # HightLight
-            kp_min, kp_max = (-1, -1)
+            rk_min, rk_max = (-1, -1)
             if self._highlight_data is not None:
-                kp_min, kp_max = self._highlight_data
+                rk_min, rk_max = self._highlight_data
 
                 lst = list(
                     filter(
-                        lambda s: (s.begin_kp == kp_min and
+                        lambda s: (s.begin_rk == rk_min and
-                                   s.end_kp == kp_max),
+                                   s.end_rk == rk_max),
                         frictions.frictions
                     )
                 )
@@ -96,7 +96,7 @@ class PlotStricklers(PamhyrPlot):
                 lambda f: f.is_full_defined(),
                 frictions
             ),
-            key=lambda s: s.begin_kp
+            key=lambda s: s.begin_rk
         )
 
         coef = flatten(
@@ -106,9 +106,9 @@ class PlotStricklers(PamhyrPlot):
             )
         )
 
-        kp = flatten(
+        rk = flatten(
             map(
-                lambda s: [s.begin_kp, s.end_kp],
+                lambda s: [s.begin_rk, s.end_rk],
                 lst
             )
         )
@@ -116,13 +116,13 @@ class PlotStricklers(PamhyrPlot):
         coef_minor = list(map(lambda s: s.minor, coef))
         coef_medium = list(map(lambda s: s.medium, coef))
 
-        self.line_kp_elevation[0] = self.canvas.axes.plot(
+        self.line_rk_elevation[0] = self.canvas.axes.plot(
-            kp, coef_minor,
+            rk, coef_minor,
             color=color, lw=1.
         )
 
-        self.line_kp_elevation[1] = self.canvas.axes.plot(
+        self.line_rk_elevation[1] = self.canvas.axes.plot(
-            kp, coef_medium,
+            rk, coef_medium,
             color=color, lw=1.
         )
 

src/View/Frictions/Table.py

@@ -113,10 +113,10 @@ class TableModel(PamhyrTableModel):
 
         if self._headers[column] == "name":
             return self._lst.get(row).name
-        elif self._headers[column] == "begin_kp":
+        elif self._headers[column] == "begin_rk":
-            return self._lst.get(row).begin_kp
+            return self._lst.get(row).begin_rk
-        elif self._headers[column] == "end_kp":
+        elif self._headers[column] == "end_rk":
-            return self._lst.get(row).end_kp
+            return self._lst.get(row).end_rk
         elif self._headers[column] == "begin_strickler":
             value = self._lst.get(row).begin_strickler
             if value is None:
@@ -144,13 +144,13 @@ class TableModel(PamhyrTableModel):
                         self._lst, row, value
                     )
                 )
-            elif self._headers[column] == "begin_kp":
+            elif self._headers[column] == "begin_rk":
                 self._undo.push(
                     SetBeginCommand(
                         self._lst, row, value
                     )
                 )
-            elif self._headers[column] == "end_kp":
+            elif self._headers[column] == "end_rk":
                 self._undo.push(
                     SetEndCommand(
                         self._lst, row, value

src/View/Frictions/UndoCommand.py

@@ -49,14 +49,14 @@ class SetBeginCommand(QUndoCommand):
 
         self._frictions = frictions
         self._index = index
-        self._old = self._frictions.get(self._index).begin_kp
+        self._old = self._frictions.get(self._index).begin_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._frictions.get(self._index).begin_kp = float(self._old)
+        self._frictions.get(self._index).begin_rk = float(self._old)
 
     def redo(self):
-        self._frictions.get(self._index).begin_kp = float(self._new)
+        self._frictions.get(self._index).begin_rk = float(self._new)
 
 
 class SetEndCommand(QUndoCommand):
@@ -65,14 +65,14 @@ class SetEndCommand(QUndoCommand):
 
         self._frictions = frictions
         self._index = index
-        self._old = self._frictions.get(self._index).end_kp
+        self._old = self._frictions.get(self._index).end_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._frictions.get(self._index).end_kp = float(self._old)
+        self._frictions.get(self._index).end_rk = float(self._old)
 
     def redo(self):
-        self._frictions.get(self._index).end_kp = float(self._new)
+        self._frictions.get(self._index).end_rk = float(self._new)
 
 
 class SetBeginStricklerCommand(QUndoCommand):

src/View/Frictions/Window.py

@@ -50,7 +50,7 @@ from View.Frictions.Table import (
 )
 
 from View.Tools.Plot.PamhyrCanvas import MplCanvas
-from View.Geometry.PlotKPZ import PlotKPZ
+from View.Frictions.PlotRKZ import PlotRKZ
 from View.Frictions.PlotStricklers import PlotStricklers
 from View.Frictions.translate import FrictionsTranslate
 
@@ -110,7 +110,7 @@ class FrictionsWindow(PamhyrWindow):
             table_view=table,
             table_headers=self._trad.get_dict("table_headers"),
             editable_headers=[
-                "name", "begin_kp", "end_kp",
+                "name", "begin_rk", "end_rk",
                 "begin_strickler", "end_strickler"
             ],
             delegates={
@@ -133,12 +133,13 @@ class FrictionsWindow(PamhyrWindow):
         self.plot_layout = self.find(QVBoxLayout, "verticalLayout")
         self.plot_layout.addWidget(self.canvas)
 
-        self.plot = PlotKPZ(
+        self.plot = PlotRKZ(
             canvas=self.canvas,
-            data=self._reach.reach,
+            reach=self._reach,
-            study=self._study,
+            river=self._study.river,
             trad=self._trad,
             toolbar=None,
+            parent=self
         )
         self.plot.draw()
 
@@ -203,7 +204,7 @@ class FrictionsWindow(PamhyrWindow):
             data = self._reach
             reach = self._reach.reach
             sec = self._frictions.get(rows[0])
-            highlight = (sec.begin_kp, sec.end_kp)
+            highlight = (sec.begin_rk, sec.end_rk)
 
         self.update_plot(highlight)
 

src/View/Frictions/translate.py

@@ -27,7 +27,7 @@ class FrictionsTranslate(MainTranslate):
     def __init__(self):
         super(FrictionsTranslate, self).__init__()
 
-        self._dict["kp"] = self._dict["unit_kp"]
+        self._dict["rk"] = self._dict["unit_rk"]
         self._dict["strickler_plot"] = _translate(
             "Frictions", "Strickler ($m^{1/3}/s$)"
         )
@@ -42,8 +42,8 @@ class FrictionsTranslate(MainTranslate):
         self._sub_dict["table_headers"] = {
             # "name": self._dict["name"],
             # "edge": self._dict["reach"],
-            "begin_kp": _translate("Frictions", "Start (m)"),
+            "begin_rk": _translate("Frictions", "Start (m)"),
-            "end_kp": _translate("Frictions", "End (m)"),
+            "end_rk": _translate("Frictions", "End (m)"),
             "begin_strickler": _translate("Frictions", "Start coefficient"),
             "end_strickler": _translate("Frictions", "End coefficient"),
         }

src/View/Geometry/MeshingDialog.py

@@ -76,11 +76,11 @@ class MeshingDialog(PamhyrDialog):
     def _init_default_values_profiles(self):
         profiles = self.profiles
 
-        self.combobox_add_items("comboBox_begin_kp", profiles)
+        self.combobox_add_items("comboBox_begin_rk", profiles)
-        self.combobox_add_items("comboBox_end_kp", profiles)
+        self.combobox_add_items("comboBox_end_rk", profiles)
 
-        self.set_combobox_text("comboBox_begin_kp", profiles[0])
+        self.set_combobox_text("comboBox_begin_rk", profiles[0])
-        self.set_combobox_text("comboBox_end_kp", profiles[-1])
+        self.set_combobox_text("comboBox_end_rk", profiles[-1])
 
     @property
     def profiles(self):
@@ -98,9 +98,9 @@ class MeshingDialog(PamhyrDialog):
         name = profile.name
 
         if name == "":
-            name = f"{profile.kp}"
+            name = f"{profile.rk}"
         else:
-            name += f" ({profile.kp})"
+            name += f" ({profile.rk})"
 
         return name
 
@@ -151,8 +151,8 @@ class MeshingDialog(PamhyrDialog):
         )
         self._linear = self.get_radio_button("radioButton_linear")
 
-        p1 = self.get_combobox_text("comboBox_begin_kp")
+        p1 = self.get_combobox_text("comboBox_begin_rk")
-        p2 = self.get_combobox_text("comboBox_end_kp")
+        p2 = self.get_combobox_text("comboBox_end_rk")
 
         self._begin_cs = self.profiles.index(p1)
         self._end_cs = self.profiles.index(p2)

src/View/Geometry/PlotKPZ.py

@@ -1,306 +0,0 @@
-# PlotKPC.py -- Pamhyr
-# Copyright (C) 2023-2024  INRAE
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# -*- coding: utf-8 -*-
-
-import logging
-
-from tools import timer
-from View.Tools.PamhyrPlot import PamhyrPlot
-
-logger = logging.getLogger()
-
-
-class PlotKPZ(PamhyrPlot):
-    def __init__(self, canvas=None, trad=None,
-                 study=None, data=None, toolbar=None,
-                 parent=None):
-        self._study = study
-
-        super(PlotKPZ, self).__init__(
-            canvas=canvas,
-            trad=trad,
-            data=data,
-            toolbar=toolbar,
-            parent=parent
-        )
-
-        self._isometric_axis = False
-
-        self.line_kp_zgl = []
-        self.line_kp_zmin = None
-        self.line_kp_zmin_zmax = None
-        self.line_kp_zmin_zmax_highlight = None
-
-        self.label_x = self._trad["unit_kp"]
-        self.label_y = self._trad["unit_height"]
-
-        self.before_plot_selected = None
-        self.plot_selected = None
-        self.after_plot_selected = None
-
-    @timer
-    def draw(self):
-        self.init_axes()
-
-        if self.data is None:
-            return
-
-        if len(self.data.profiles) == 0:
-            return
-
-        profiles_defined = any(
-            filter(
-                lambda profile: len(profile) > 0,
-                self.data.profiles
-            )
-        )
-
-        if not profiles_defined:
-            self._init = False
-            return
-
-        self.draw_z_line()
-        self.draw_z_line_highlight()
-        self.draw_current()
-        self.draw_gl()
-        self.draw_bottom()
-        self.draw_profiles_hs(self._data)
-
-        self.idle()
-        self._init = True
-
-    def draw_z_line(self):
-        kp = self.data.get_kp_complete_profiles()
-        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=self.color_plot,
-            lw=1.
-        )
-
-    def draw_z_line_highlight(self):
-        if self._highlight_data is not None:
-            kp = self.data.get_kp_complete_profiles()
-            z_min = self.data.get_z_min()
-            z_max = self.data.get_z_max()
-
-            kp_min, kp_max = self._highlight_data
-
-            indexes = list(
-                map(
-                    lambda x: x[0],
-                    filter(
-                        lambda x: kp_min <= x[1] <= kp_max,
-                        enumerate(kp)
-                    )
-                )
-            )
-
-            def indexes_filter(data): return list(
-                map(
-                    lambda x: x[1],
-                    filter(
-                        lambda x: x[0] in indexes,
-                        enumerate(data)
-                    )
-                )
-            )
-
-            ikp = indexes_filter(kp)
-            imin = indexes_filter(z_min)
-            imax = indexes_filter(z_max)
-
-            self.line_kp_zmin_zmax_highlight = self.canvas.axes.vlines(
-                x=ikp,
-                ymin=imin, ymax=imax,
-                color=self.color_plot_highlight,
-                lw=1.
-            )
-
-    def draw_current(self):
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-        z_max = self.data.get_z_max()
-
-        self.plot_selected, = self.canvas.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color=self.color_plot_current, lw=1.5
-        )
-        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=self.color_plot_previous, lw=1.5, 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=self.color_plot_next, lw=1.5, linestyle='--'
-        )
-        self.after_plot_selected.set_visible(False)
-
-    def draw_gl(self):
-        kp = self.data.get_kp_complete_profiles()
-
-        ind = 0
-        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.,
-                    color=self.colors[ind % len(self.colors)],
-                    linestyle=self.linestyle[ind // len(self.colors)]
-                )
-            )
-            ind += 1
-
-    def draw_bottom(self):
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-
-        self.line_kp_zmin, = self.canvas.axes.plot(
-            kp, z_min,
-            linestyle=":", lw=1.5,
-            color='lightgrey'
-        )
-
-    def draw_profiles_hs(self, reach):
-        lhs = filter(
-            lambda hs: hs._input_reach.reach is reach,
-            filter(
-                lambda hs: hs._input_reach is not None,
-                self._study.river.hydraulic_structures.lst
-            )
-        )
-
-        for hs in lhs:
-            x = hs.input_kp
-            z_min = reach.get_z_min()
-            z_max = reach.get_z_max()
-
-            self.canvas.axes.plot(
-                [x, x],
-                [min(z_min), max(z_max)],
-                linestyle="--",
-                lw=1.,
-                color=self.color_plot_previous,
-            )
-
-            self.canvas.axes.annotate(
-                " > " + hs.name,
-                (x, max(z_max)),
-                horizontalalignment='left',
-                verticalalignment='top',
-                annotation_clip=True,
-                fontsize=9, color=self.color_plot_previous,
-            )
-
-    @timer
-    def update(self):
-        if not self._init:
-            self.draw()
-            return
-
-        self.update_gl()
-        self.update_current()
-
-        self.update_idle()
-
-    def update_current(self):
-        if self._current_data_update:
-            ind = self._current_data
-            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:
-                profile = self.data.profile(before)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.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:
-                profile = self.data.profile(ind)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.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:
-                profile = self.data.profile(after)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.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)
-
-    def update_gl(self):
-        if self._current_data_update:
-            return
-
-        kp = self.data.get_kp_complete_profiles()
-        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:
-            logger.warning(f"Failed to update graphic KPZ: {e}")

src/View/Geometry/PlotRKZ.py

@@ -0,0 +1,372 @@
+# PlotRKC.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import timer
+from View.Tools.PamhyrPlot import PamhyrPlot
+from PyQt5.QtWidgets import QApplication
+from PyQt5.QtCore import (
+    Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
+)
+
+logger = logging.getLogger()
+
+
+class PlotRKZ(PamhyrPlot):
+    def __init__(self, canvas=None, trad=None,
+                 study=None, data=None, toolbar=None,
+                 table=None, parent=None):
+        self._study = study
+
+        super(PlotRKZ, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=data,
+            toolbar=toolbar,
+            table=table,
+            parent=parent
+        )
+
+        self._isometric_axis = False
+
+        self.line_rk_zgl = []
+        self.line_rk_zmin = None
+        self.line_rk_zmin_zmax = None
+        self.line_rk_zmin_zmax_highlight = None
+
+        self.label_x = self._trad["unit_rk"]
+        self.label_y = self._trad["unit_height"]
+
+        self.before_plot_selected = None
+        self.plot_selected = None
+        self.after_plot_selected = None
+        self.parent = parent
+        self._table = table
+        self._colors = []
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        ind, point = self._closest_rk(event)
+        if self.parent._table is None:
+            return
+        self.parent._table.blockSignals(True)
+        if modifiers == Qt.ControlModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if ind in rows:
+                rows.remove(ind)
+            else:
+                rows.append(ind)
+            self._select_in_table(rows)
+        elif modifiers == Qt.ShiftModifier:
+            rows = sorted(list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            ))
+            if len(rows) > 0:
+                i1 = min(rows[0], rows[-1], ind)
+                i2 = max(rows[0], rows[-1], ind)
+            else:
+                i1 = ind
+                i2 = ind
+            self._select_range_in_table(i1, i2)
+        else:
+            self._select_in_table([ind])
+        self.parent._table.blockSignals(False)
+
+        return
+
+    def _closest_rk(self, event):
+
+        s = event.artist.get_segments()
+        x = [i[0, 0] for i in s]
+        mx = event.mouseevent.xdata
+        points = enumerate(x)
+
+        def dist_mouse(point):
+            x = point[1]
+            d = abs(mx - x)
+            return d
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _select_in_table(self, ind):
+        if self._table is None:
+            return
+
+        self._table.setFocus()
+        selection = self._table.selectionModel()
+        index = QItemSelection()
+
+        if len(ind) == 0:
+            return
+
+        for i in ind:
+            index.append(QItemSelectionRange(self._table.model().index(i, 0)))
+
+        selection.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+
+        if len(ind) > 0:
+            self._table.scrollTo(self._table.model().index(ind[-1], 0))
+
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))
+
+    @timer
+    def draw(self):
+        self.init_axes()
+
+        if self.data is None:
+            return
+
+        if len(self.data.profiles) == 0:
+            return
+
+        profiles_defined = any(
+            filter(
+                lambda profile: len(profile) > 0,
+                self.data.profiles
+            )
+        )
+
+        if not profiles_defined:
+            self._init = False
+            return
+
+        self.draw_z_line()
+        self.draw_lr()
+        self.draw_gl()
+        self.draw_bottom()
+        self.draw_profiles_hs(self._data)
+
+        self.idle()
+        self._init = True
+
+    def draw_z_line(self):
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+        z_max = self.data.get_z_max()
+
+        self._colors, self._style = self.color_hightlight()
+
+        self.line_rk_zmin_zmax = self.canvas.axes.vlines(
+            x=rk, ymin=z_min, ymax=z_max,
+            color=self._colors,
+            linestyle=self._style,
+            lw=1.,
+            picker=10,
+        )
+
+    def color_hightlight(self):
+        rows = sorted(list(
+            set(
+                (i.row() for i in self.parent.tableView.selectedIndexes())
+            )
+        ))
+        colors = [self.color_plot for row in range(len(self._data))]
+        style = ["-" for row in range(len(self._data))]
+        if len(rows) > 0:
+            for row in rows:
+                colors[row] = self.color_plot_current
+            if rows[0] > 0:
+                colors[rows[0]-1] = self.color_plot_previous
+                style[rows[0]-1] = "--"
+            if rows[-1] < len(self._data)-1:
+                colors[rows[-1]+1] = self.color_plot_next
+                style[rows[-1]+1] = "--"
+        return colors, style
+
+    def draw_lr(self):
+        rk = self.data.get_rk_complete_profiles()
+        lz = []
+        rz = []
+
+        self.line_lr = []
+        for z in self.data.get_z():
+            lz.append(z[0])
+            rz.append(z[-1])
+
+        line = self.canvas.axes.plot(
+            rk, lz,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+        line = self.canvas.axes.plot(
+            rk, rz,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+    def draw_gl(self):
+        rk = self.data.get_rk_complete_profiles()
+
+        ind = 0
+        self.line_rk_zgl = []
+        for z in self.data.get_guidelines_z():
+            # Is incomplete guideline?
+            if len(z) != len(rk):
+                continue
+
+            self.line_rk_zgl.append(
+                self.canvas.axes.plot(
+                    rk, z, lw=1.,
+                    color=self.colors[ind % len(self.colors)],
+                    linestyle=self.linestyle[ind // len(self.colors)]
+                )
+            )
+            ind += 1
+
+    def draw_bottom(self):
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+
+        self.line_rk_zmin, = self.canvas.axes.plot(
+            rk, z_min,
+            linestyle=":", lw=1.5,
+            color='lightgrey'
+        )
+
+    def draw_profiles_hs(self, reach):
+        lhs = filter(
+            lambda hs: hs._input_reach.reach is reach,
+            filter(
+                lambda hs: hs._input_reach is not None,
+                self._study.river.hydraulic_structures.lst
+            )
+        )
+
+        for hs in lhs:
+            x = hs.input_rk
+            if x is not None:
+                z_min = reach.get_z_min()
+                z_max = reach.get_z_max()
+
+                self.canvas.axes.plot(
+                    [x, x],
+                    [min(z_min), max(z_max)],
+                    linestyle="--",
+                    lw=1.,
+                    color=self.color_plot_previous,
+                )
+
+                self.canvas.axes.annotate(
+                    " > " + hs.name,
+                    (x, max(z_max)),
+                    horizontalalignment='left',
+                    verticalalignment='top',
+                    annotation_clip=True,
+                    fontsize=9, color=self.color_plot_previous,
+                )
+
+    @timer
+    def update(self):
+        if not self._init:
+            self.draw()
+            return
+
+        self.update_lr()
+        self.update_gl()
+        self.update_current()
+
+        self.update_idle()
+
+    def update_current(self):
+        if self._current_data_update:
+            self._colors, self._style = self.color_hightlight()
+            self.line_rk_zmin_zmax.set_colors(self._colors)
+            self.line_rk_zmin_zmax.set_linestyle(self._style)
+
+    def update_gl(self):
+        if self._current_data_update:
+            return
+
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+        z_max = self.data.get_z_max()
+
+        self.line_rk_zmin.set_data(rk, z_min)
+
+#        TODO comprendre à quoi sert ce bout de code
+#        ========>
+#        self.line_rk_zmin_zmax.remove()
+#        self._colors, self._style = self.color_hightlight()
+#        self.line_rk_zmin_zmax = self.canvas.axes.vlines(
+#            x=rk,
+#            ymin=z_min,
+#            ymax=z_max,
+#            color=self._colors,
+#            linestyle = self._style,
+#            lw=1.
+#        )
+#        <========
+
+        z_complete = self.data.get_guidelines_z()
+        try:
+            for i in range(len(self.line_rk_zgl)):
+                self.line_rk_zgl[i][0].set_data(
+                    rk, z_complete[i]
+                )
+        except Exception as e:
+            logger.warning(f"Failed to update graphic RKZ: {e}")
+
+    def update_lr(self):
+        for line in self.line_lr:
+            line[0].remove()
+
+        self.draw_lr()

src/View/Geometry/PlotXY.py

@@ -18,22 +18,27 @@
 
 from tools import timer, trace
 from View.Tools.PamhyrPlot import PamhyrPlot
+from matplotlib import collections
+import numpy as np
 
 from PyQt5.QtCore import (
-    QCoreApplication
+    QCoreApplication, Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
 )
+from PyQt5.QtWidgets import QApplication
 
 _translate = QCoreApplication.translate
 
 
 class PlotXY(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, data=None, toolbar=None,
-                 parent=None):
+                 table=None, parent=None):
         super(PlotXY, self).__init__(
             canvas=canvas,
             trad=trad,
             data=data,
             toolbar=toolbar,
+            table=table,
             parent=parent
         )
 
@@ -46,6 +51,116 @@ class PlotXY(PamhyrPlot):
         self.before_plot_selected = None
         self.plot_selected = None
         self.after_plot_selected = None
+        self.parent = parent
+        self.line_xy_collection = None
+        self._table = table
+        self._colors = []
+        self._style = []
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        ind, point = self._closest_section(event)
+        if self._table is None:
+            return
+        self._table.blockSignals(True)
+        if modifiers == Qt.ControlModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if ind in rows:
+                rows.remove(ind)
+                self._select_in_table(rows)
+            else:
+                self._select_in_table(rows + [ind])
+        elif modifiers == Qt.ShiftModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if len(rows) > 0:
+                i1 = min(rows[0], rows[-1], ind)
+                i2 = max(rows[0], rows[-1], ind)
+            else:
+                i1 = ind
+                i2 = ind
+            self._select_range_in_table(i1, i2)
+        else:
+            self._select_in_table([ind])
+        self._table.blockSignals(False)
+
+        return
+
+    def _closest_section(self, event):
+        axes = self.canvas.axes
+        mx = event.mouseevent.xdata
+        my = event.mouseevent.ydata
+        bx, by = axes.get_xlim(), axes.get_ylim()
+        ratio = (bx[0] - bx[1]) / (by[0] - by[1])
+
+        segments = event.artist.get_segments()
+        ind = event.ind
+
+        points = []
+        for i in ind:
+            points = points + [[i, j] for j in segments[i]]
+
+        def dist_mouse(point):
+            x, y = point[1]
+            d2 = (((mx - x) / ratio) ** 2) + ((my - y) ** 2)
+            return d2
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _select_in_table(self, ind):
+        if self._table is None:
+            return
+        self._table.setFocus()
+        selection = self._table.selectionModel()
+        index = QItemSelection()
+        if len(ind) == 0:
+            return
+        for i in ind:
+            index.append(QItemSelectionRange(self._table.model().index(i, 0)))
+        selection.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+
+        if len(ind) > 0:
+            self._table.scrollTo(self._table.model().index(ind[-1], 0))
+
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))
 
     @timer
     def draw(self):
@@ -63,33 +178,42 @@ class PlotXY(PamhyrPlot):
         self.draw_xy()
         self.draw_lr()
         self.draw_gl()
-        self.draw_current()
 
         self.idle()
         self._init = True
 
     def draw_xy(self):
-        kp = self.data.get_kp_complete_profiles()
-
-        kp_min, kp_max = (-1, -1)
-        if self._highlight_data is not None:
-            kp_min, kp_max = self._highlight_data
-
-        def color_hightlight(kp):
-            if kp_min <= kp <= kp_max:
-                return self.color_plot_highlight
-            return self.color_plot
-
         self.line_xy = []
-        for x, y, kp in zip(self.data.get_x(),
+        for xy in zip(self.data.get_x(), self.data.get_y()):
-                            self.data.get_y(),
+            self.line_xy.append(np.column_stack(xy))
-                            kp):
+
-            line = self.canvas.axes.plot(
+        self._colors, self._style = self.color_hightlight()
-                x, y,
+        self.line_xy_collection = collections.LineCollection(
-                color=color_hightlight(kp),
+            self.line_xy,
-                **self.plot_default_kargs
+            colors=self._colors,
+            linestyle=self._style,
+            picker=10
+        )
+        self.canvas.axes.add_collection(self.line_xy_collection)
+
+    def color_hightlight(self):
+        rows = sorted(list(
+            set(
+                (i.row() for i in self.parent.tableView.selectedIndexes())
             )
-            self.line_xy.append(line)
+        ))
+        colors = [self.color_plot for row in range(len(self._data))]
+        style = ["-" for row in range(len(self._data))]
+        if len(rows) > 0:
+            for row in rows:
+                colors[row] = self.color_plot_current
+            if rows[0] > 0:
+                colors[rows[0]-1] = self.color_plot_previous
+                style[rows[0]-1] = "--"
+            if rows[-1] < len(self._data)-1:
+                colors[rows[-1]+1] = self.color_plot_next
+                style[rows[-1]+1] = "--"
+        return colors, style
 
     def draw_lr(self):
         lx = []
@@ -136,33 +260,6 @@ class PlotXY(PamhyrPlot):
             self.line_gl.append(line)
             ind += 1
 
-    def draw_current(self):
-        # Previous profile
-        self.before_plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_previous, linestyle="--",
-            **self.plot_default_kargs
-        )
-        self.before_plot_selected.set_visible(False)
-
-        # Current profile
-        self.plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_current, **self.plot_default_kargs
-        )
-        self.plot_selected.set_visible(False)
-
-        # Next profile
-        self.after_plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_next, linestyle='--',
-            **self.plot_default_kargs
-        )
-        self.after_plot_selected.set_visible(False)
-
     @timer
     def update(self):
         if not self._init:
@@ -183,21 +280,24 @@ class PlotXY(PamhyrPlot):
         x_complete = list(self.data.get_guidelines_x())
         y_complete = list(self.data.get_guidelines_y())
 
-        for i in range(self.data.number_profiles):
+#        TODO comprendre à quoi sert ce bout de code
-            if i < len(self.line_xy):
+#        ========>
-                self.line_xy[i][0].set_data(
+#        for i in range(self.data.number_profiles):
-                    self.data.profile(i).x(),
+#            if i < len(self.line_xy):
-                    self.data.profile(i).y()
+#                self.line_xy[i][0].set_data(
-                )
+#                    self.data.profile(i).x(),
-            else:
+#                    self.data.profile(i).y()
-                self.line_xy.append(
+#                )
-                    self.canvas.axes.plot(
+#            else:
-                        self.data.profile(i).x(),
+#                self.line_xy.append(
-                        self.data.profile(i).y(),
+#                    self.canvas.axes.plot(
-                        color='r',
+#                        self.data.profile(i).x(),
-                        **self.plot_default_kargs
+#                        self.data.profile(i).y(),
-                    )
+#                        color='r',
-                )
+#                        **self.plot_default_kargs
+#                    )
+#                )
+#        <========
 
         for i in range(len(x_complete)):
             if i < len(self.line_gl):
@@ -215,32 +315,9 @@ class PlotXY(PamhyrPlot):
 
     def update_current(self):
         if self._current_data_update:
-            ind = self._current_data
+            self._colors, self._style = self.color_hightlight()
-            before = ind - 1
+            self.line_xy_collection.set_colors(self._colors)
-            after = ind + 1
+            self.line_xy_collection.set_linestyle(self._style)
-
-            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:
-                self.before_plot_selected.set_data(
-                    self.data.profile(before).x(),
-                    self.data.profile(before).y()
-                )
-                self.before_plot_selected.set_visible(True)
-
-            if 0 <= ind < self.data.number_profiles:
-                self.plot_selected.set_data(self.data.profile(ind).x(),
-                                            self.data.profile(ind).y())
-                self.plot_selected.set_visible(True)
-
-            if 0 <= after < self.data.number_profiles:
-                self.after_plot_selected.set_data(
-                    self.data.profile(after).x(),
-                    self.data.profile(after).y()
-                )
-                self.after_plot_selected.set_visible(True)
 
     def update_lr(self):
         for line in self.line_lr:

src/View/Geometry/Profile/Plot.py

@@ -24,10 +24,12 @@ from tools import timer, trace
 from View.Tools.PamhyrPlot import PamhyrPlot
 
 from PyQt5.QtCore import (
-    Qt, QCoreApplication, QItemSelectionModel
+    Qt, QCoreApplication, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
 )
 
 from PyQt5.QtWidgets import QApplication
+from matplotlib.widgets import RectangleSelector
 
 _translate = QCoreApplication.translate
 
@@ -46,6 +48,7 @@ class Plot(PamhyrPlot):
         )
 
         self._table = table
+        self._parent = parent
         self._z_note = None
         self._z_line = None
         self._z_fill_between = None
@@ -53,7 +56,7 @@ class Plot(PamhyrPlot):
         self.line_xy = []
         self.line_gl = []
 
-        self.label_x = self._trad["unit_kp"]
+        self.label_x = self._trad["unit_rk"]
         self.label_y = self._trad["unit_height"]
 
         self.before_plot_selected = None
@@ -68,40 +71,86 @@ class Plot(PamhyrPlot):
             None                # Hydrolic values (z, wet_area,
                                 # wet_preimeter, water_width)
         )
+        self._onpickevent = None
+        self._rect_select = RectangleSelector(
+            ax=self.canvas.axes,
+            onselect=self.rect_select_callback,
+            useblit=True,
+            button=[1],  # don't use middle nor right button
+            minspanx=2.0,
+            minspany=2.0,
+            spancoords='pixels',
+            interactive=False
+        )
+
+    def onrelease(self, event):
+        # we need to do that to prevent conflicst
+        # between onpick and rect_select_callback
+        modifiers = QApplication.keyboardModifiers()
+        points, hyd = self.highlight
+        if self._onpickevent is not None:
+            ind, point = self._closest_point(self._onpickevent)
+            if modifiers == Qt.ControlModifier:
+                rows = self._parent.index_selected_rows()
+                if ind in rows:
+                    rows.remove(ind)
+                    del (points[ind])
+                    self.highlight = (points, hyd)
+                    self._select_in_table(rows)
+                else:
+                    self.highlight = (points+[point], hyd)
+                    self._select_in_table(rows+[ind])
+            elif modifiers == Qt.ShiftModifier:
+                rows = self._parent.index_selected_rows()
+                if len(rows) > 0:
+                    i1 = min(rows[0], rows[-1], ind)
+                    i2 = max(rows[0], rows[-1], ind)
+                    p = [
+                            [self.data.points[i].x, self.data.points[i].y]
+                            for i in range(i1, i2)
+                        ]
+                else:
+                    i1 = ind
+                    i2 = ind
+                    p = [point]
+                self.highlight = (p, hyd)
+                self._select_range_in_table(i1, i2)
+            else:
+                self.highlight = ([point], hyd)
+                self._select_in_table([ind])
+
+        self._onpickevent = None
 
     def onpick(self, event):
         if event.mouseevent.inaxes != self.canvas.axes:
             return
-
+        if event.mouseevent.button.value != 1:
-        modifiers = QApplication.keyboardModifiers()
-        if modifiers != Qt.ControlModifier:
             return
 
-        _, hyd = self.highlight
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
 
-        ind, point = self._closer_point(event)
+        self._onpickevent = event
-
-        self.highlight = ([point], hyd)
-        self._select_in_table(ind)
-
-        self.update()
         return
 
     def onclick(self, event):
         if event.inaxes != self.canvas.axes:
             return
-
+        if event.button.value == 1:
-        modifiers = QApplication.keyboardModifiers()
-        if modifiers != Qt.ShiftModifier:
             return
 
         points, _ = self.highlight
 
         z = self._get_z_from_click(event)
-        if z < self.data.z_min():
+        if z < self.data.z_min() or event.button.value == 2:
+            self.highlight = (points, None)
+            self.update()
             return
 
-        a, p, w = self._compute_hydrolics(z)
+        a, p, w = self._compute_hydraulics(z)
 
         logger.debug(f"{z, a, p, w}")
 
@@ -110,7 +159,7 @@ class Plot(PamhyrPlot):
         self.update()
         return
 
-    def select_points_from_indexes(self, indexes):
+    def select_points_from_indices(self, indices):
         data = self.data
         _, hyd = self.highlight
 
@@ -118,7 +167,7 @@ class Plot(PamhyrPlot):
             map(
                 lambda e: e[1],
                 filter(
-                    lambda e: e[0] in indexes,
+                    lambda e: e[0] in indices,
                     enumerate(
                         zip(data.get_station(), data.z())
                     )
@@ -133,9 +182,13 @@ class Plot(PamhyrPlot):
         if self._table is not None:
             self._table.blockSignals(True)
             self._table.setFocus()
-
             selection = self._table.selectionModel()
-            index = self._table.model().index(ind, 0)
+            index = QItemSelection()
+            if len(ind) > 0:
+                for i in ind:
+                    index.append(QItemSelectionRange(
+                        self._table.model().index(i, 0))
+                    )
             selection.select(
                 index,
                 QItemSelectionModel.Rows |
@@ -143,10 +196,27 @@ class Plot(PamhyrPlot):
                 QItemSelectionModel.Select
             )
 
-            self._table.scrollTo(index)
+            if len(ind) > 0:
+                self._table.scrollTo(self._table.model().index(ind[-1], 0))
             self._table.blockSignals(False)
 
-    def _closer_point(self, event):
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.blockSignals(True)
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))
+            self._table.blockSignals(False)
+
+    def _closest_point(self, event):
         points_ind = event.ind
         axes = self.canvas.axes
         bx, by = axes.get_xlim(), axes.get_ylim()
@@ -166,22 +236,62 @@ class Plot(PamhyrPlot):
 
         def dist_mouse(point):
             x, y = point[1]
-            d = sqrt(
+            d2 = ((mx - x) / ratio) ** 2 + ((my - y) ** 2)
-                    (((mx - x) / ratio) ** 2) +
+            return d2
-                    ((my - y) ** 2)
-            )
-            return d
 
-        closer = min(
+        closest = min(
             points, key=dist_mouse
         )
 
-        return closer
+        return closest
 
     def _get_z_from_click(self, event):
         return event.ydata
 
-    def _compute_hydrolics(self, z):
+    def rect_select_callback(self, eclick, erelease):
+
+        points, hyd = self.highlight
+        x1, y1 = eclick.xdata, eclick.ydata
+        x2, y2 = erelease.xdata, erelease.ydata
+
+        if (max(abs(x1-x2), abs(y1-y2)) < 0.001):
+            return
+        modifiers = QApplication.keyboardModifiers()
+
+        x1, y1 = eclick.xdata, eclick.ydata
+        x2, y2 = erelease.xdata, erelease.ydata
+
+        inds, points2 = self._points_in_rectangle(x1, y1, x2, y2)
+        self._onclickevent = None
+        if modifiers == Qt.ControlModifier:
+            rows = self._parent.index_selected_rows()
+            if all(i in rows for i in inds):
+                for ind in sorted(inds, reverse=True):
+                    rows.remove(ind)
+                    del (points[ind])
+                self.highlight = (points, hyd)
+                self._select_in_table(rows)
+            else:
+                self.highlight = (points+points2, hyd)
+                self._select_in_table(rows+inds)
+        else:
+            self.highlight = (points2, hyd)
+            self._select_in_table(inds)
+        return
+
+    def _points_in_rectangle(self, x1, y1, x2, y2):
+        # TODO: use lambdas
+        listi = []
+        listp = []
+        station = self.data._get_station(self.data.points)
+        for i, p in enumerate(self.data.points):
+            if (min(x1, x2) < station[i] < max(x1, x2)
+                    and min(y1, y2) < p.z < max(y1, y2)):
+                listi.append(i)
+                listp.append((station[i], p.z))
+        return listi, listp
+
+    def _compute_hydraulics(self, z):
         profile = self.data
 
         points = profile.wet_points(z)
@@ -210,7 +320,7 @@ class Plot(PamhyrPlot):
         self.profile_line2D, = self.canvas.axes.plot(
             x, y, color=self.color_plot,
             lw=1.5, markersize=7, marker='+',
-            picker=30
+            picker=10
         )
 
         self.draw_annotation(x, y)
@@ -269,12 +379,16 @@ class Plot(PamhyrPlot):
                     x, y,
                     color=self.color_plot_highlight,
                     lw=1.5, markersize=7, marker='+',
-                    picker=30
                 )
             )
 
         if hyd is not None:
             self.draw_highligth_z_line(*hyd)
+        else:
+            if self._z_note is not None:
+                self._z_note.set_visible(False)
+                self._z_line[0].set_visible(False)
+                self._z_fill_between.set_visible(False)
 
     def draw_highligth_z_line(self, z, a, p, w):
         text = (
@@ -299,6 +413,7 @@ class Plot(PamhyrPlot):
                 xlim, [z, z],
                 color=self.color_plot_river_water
             )
+            self._z_line[0].set_visible(True)
 
             self._z_note = self.canvas.axes.annotate(
                 text, pos,
@@ -310,12 +425,15 @@ class Plot(PamhyrPlot):
                 fontweight='bold',
                 alpha=0.7
             )
+            self._z_note.set_visible(True)
         else:
             self.draw_highligth_z_line_fill(x, y, z)
 
             self._z_line[0].set_data(xlim, [z, z])
             self._z_note.set_position(pos)
             self._z_note.set_text(text)
+            self._z_line[0].set_visible(True)
+            self._z_note.set_visible(True)
 
     def draw_highligth_z_line_fill(self, x, y, z):
         if self._z_fill_between is not None:

src/View/Geometry/Profile/Window.py

@@ -64,7 +64,7 @@ class ProfileWindow(PamhyrWindow):
         trad = GeometryProfileTranslate()
         name = (
             trad[self._pamhyr_name] +
-            f" - {self._profile.name} {self._profile.kp}"
+            f" - {self._profile.name} {self._profile.rk}"
         )
 
         super(ProfileWindow, self).__init__(
@@ -115,7 +115,8 @@ class ProfileWindow(PamhyrWindow):
             data=self._profile,
             trad=self._trad,
             toolbar=self._toolbar,
-            table=self.find(QTableView, "tableView")
+            table=self.find(QTableView, "tableView"),
+            parent=self
         )
         self._plot.draw()
 
@@ -146,7 +147,7 @@ class ProfileWindow(PamhyrWindow):
 
     def update_points_selection(self):
         rows = self.index_selected_rows()
-        self._plot.select_points_from_indexes(rows)
+        self._plot.select_points_from_indices(rows)
 
     def update(self):
         self.update_plot()

src/View/Geometry/Table.py

@@ -55,8 +55,8 @@ class GeometryReachTableModel(PamhyrTableModel):
             return self._data.profile(index.row()).name
 
         if role == Qt.DisplayRole and index.column() == 1:
-            kp = self._data.profile(index.row()).kp
+            rk = self._data.profile(index.row()).rk
-            return f"{kp:.4f}"
+            return f"{rk:.4f}"
 
         if role == Qt.DisplayRole and index.column() == 2:
             return str(self._data.profile(index.row()).nb_points)
@@ -94,9 +94,9 @@ class GeometryReachTableModel(PamhyrTableModel):
 
                 if index.column() == 1:
                     self._undo.push(
-                        SetKPCommand(
+                        SetRKCommand(
                             self._data, index.row(),
-                            self._data.profile(index.row()).kp,
+                            self._data.profile(index.row()).rk,
                             value
                         )
                     )
@@ -247,12 +247,12 @@ class GeometryReachTableModel(PamhyrTableModel):
         self.layoutAboutToBeChanged.emit()
         self.layoutChanged.emit()
 
-    def update_kp(self, mesher, data):
+    def update_rk(self, mesher, data):
         self.layoutAboutToBeChanged.emit()
 
         self._undo.push(
             MeshingCommand(
-                self._data, mesher, data, "update_kp"
+                self._data, mesher, data, "update_rk"
             )
         )
 

src/View/Geometry/Translate.py

@@ -61,7 +61,7 @@ class GeometryTranslate(MainTranslate):
 
         self._sub_dict["table_headers"] = {
             "name": self._dict["name"],
-            "kp": self._dict["unit_kp"],
+            "rk": self._dict["unit_rk_short"],
             "poins": _translate("Geometry", "Points"),
         }
 

src/View/Geometry/UndoCommand.py

@@ -56,16 +56,16 @@ class SetNameCommand(SetDataCommand):
         self._reach.profile(self._index).name = self._new
 
 
-class SetKPCommand(SetDataCommand):
+class SetRKCommand(SetDataCommand):
     def __init__(self, reach, index, old_value, new_value):
         self.type = float
-        super(SetKPCommand, self).__init__(reach, index, old_value, new_value)
+        super(SetRKCommand, self).__init__(reach, index, old_value, new_value)
 
     def undo(self):
-        self._reach.profile(self._index).kp = self._old
+        self._reach.profile(self._index).rk = self._old
 
     def redo(self):
-        self._reach.profile(self._index).kp = self._new
+        self._reach.profile(self._index).rk = self._new
 
 
 class AddCommand(QUndoCommand):
@@ -243,8 +243,8 @@ class MeshingCommand(QUndoCommand):
 
     def redo(self):
         if self._new_profiles is None:
-            if self._command == "update_kp":
+            if self._command == "update_rk":
-                self._mesher.update_kp(
+                self._mesher.update_rk(
                     self._reach,
                     **self._data
                 )

src/View/Geometry/UpdateRKDialog.py

@@ -1,4 +1,4 @@
-# UpdateKPDialog.py -- Pamhyr
+# UpdateRKDialog.py -- Pamhyr
 # Copyright (C) 2023-2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -28,16 +28,16 @@ from PyQt5.QtCore import (
 
 from PyQt5.QtWidgets import (
     QDialogButtonBox, QComboBox, QUndoStack, QShortcut,
-    QDoubleSpinBox,
+    QDoubleSpinBox, QButtonGroup,
 )
 
 
-class UpdateKPDialog(PamhyrDialog):
+class UpdateRKDialog(PamhyrDialog):
-    _pamhyr_ui = "UpdateKPOptions"
+    _pamhyr_ui = "UpdateRKOptions"
-    _pamhyr_name = "UpdateKP"
+    _pamhyr_name = "UpdateRK"
 
     def __init__(self, reach, trad=None, parent=None):
-        super(UpdateKPDialog, self).__init__(
+        super(UpdateRKDialog, self).__init__(
             title=trad[self._pamhyr_name],
             trad=trad,
             options=[],
@@ -50,16 +50,22 @@ class UpdateKPDialog(PamhyrDialog):
         self._init_default_values()
 
     def _init_default_values(self):
-        self._space_step = 50.0
+        gl, _ = self._reach.compute_guidelines()
-        self._lplan = False
+        self._gl = list(gl)
-        self._lm = "3"
+
-        self._linear = False
-        self._begin_cs = -1
-        self._end_cs = -1
         self._begin_dir = "un"
         self._end_dir = "np"
+
+        lower_gl = list(map(str.lower, self._gl))
+        for i, gl in enumerate(lower_gl):
+            if gl == "rd":
+                self._begin_dir = self._gl[i]
+            elif gl == "rg":
+                self._end_dir = self._gl[i]
+
+        self._orientation = 0
         self._origin = self._reach.profile(0)
-        self._origin_value = self._reach.profile(0).kp
+        self._origin_value = self._reach.profile(0).rk
 
         self._init_default_values_profiles()
         self._init_default_values_guidelines()
@@ -69,14 +75,25 @@ class UpdateKPDialog(PamhyrDialog):
 
         self.combobox_add_items("comboBox_origin", profiles)
 
-        self.find(QComboBox, "comboBox_origin").currentIndexChanged.connect(
+        self.find(QComboBox, "comboBox_origin")\
-            self.changed_profile)
+            .currentIndexChanged\
+            .connect(
+                self.changed_profile
+            )
+
+        buttonbox = self.find(QButtonGroup, "buttonGroup_orientation")
+
+        for button in buttonbox.buttons():
+            name = button.objectName()
+            i = int(name.split('_')[-1])
+
+            buttonbox.setId(button, i)
 
     def changed_profile(self):
         origin = self.get_combobox_text("comboBox_origin")
         self.set_double_spin_box(
             "doubleSpinBox_origin",
-            self._reach.profile(self.profiles.index(origin)).kp
+            self._reach.profile(self.profiles.index(origin)).rk
         )
 
     @property
@@ -95,18 +112,15 @@ class UpdateKPDialog(PamhyrDialog):
         name = profile.name
 
         if name == "":
-            name = f"{profile.kp}"
+            name = f"{profile.rk}"
         else:
-            name += f" ({profile.kp})"
+            name += f" ({profile.rk})"
 
         return name
 
     def _init_default_values_guidelines(self):
-        gl, _ = self._reach.compute_guidelines()
+        bgl = ['un'] + self._gl + ['np']
-        gl = list(gl)
+        egl = ['un'] + self._gl + ['np']
-
-        bgl = ['un'] + gl + ['np']
-        egl = ['un'] + gl + ['np']
 
         self.combobox_add_items("comboBox_begin_gl", bgl)
         self.combobox_add_items("comboBox_end_gl", egl)
@@ -114,6 +128,10 @@ class UpdateKPDialog(PamhyrDialog):
         self.set_combobox_text("comboBox_begin_gl", self._begin_dir)
         self.set_combobox_text("comboBox_end_gl", self._end_dir)
 
+    @property
+    def orientation(self):
+        return self._orientation
+
     @property
     def origin(self):
         return self._origin
@@ -133,11 +151,12 @@ class UpdateKPDialog(PamhyrDialog):
     def accept(self):
         origin = self.get_combobox_text("comboBox_origin")
         self._origin = self.profiles.index(origin)
-
         self._origin_value = self.get_double_spin_box("doubleSpinBox_origin")
-
         self._begin_dir = self.get_combobox_text("comboBox_begin_gl")
         self._end_dir = self.get_combobox_text("comboBox_end_gl")
+        self._orientation = self.get_checked_id_button_group(
+            "buttonGroup_orientation"
+        )
 
         super().accept()
 

src/View/Geometry/Window.py

@@ -36,7 +36,7 @@ from PyQt5.QtCore import (
 from PyQt5.QtWidgets import (
     QApplication, QMainWindow, QFileDialog, QCheckBox,
     QUndoStack, QShortcut, QTableView, QHeaderView,
-    QAction, QSlider, QPushButton, QVBoxLayout,
+    QAction, QPushButton, QVBoxLayout,
     QLabel, QAbstractItemView,
 )
 
@@ -54,9 +54,9 @@ from Meshing.Mage import (
 from View.Geometry.Table import GeometryReachTableModel
 from View.Geometry.PlotXY import PlotXY
 from View.Geometry.PlotAC import PlotAC
-from View.Geometry.PlotKPZ import PlotKPZ
+from View.Geometry.PlotRKZ import PlotRKZ
 from View.Geometry.MeshingDialog import MeshingDialog
-from View.Geometry.UpdateKPDialog import UpdateKPDialog
+from View.Geometry.UpdateRKDialog import UpdateRKDialog
 from View.Geometry.PurgeDialog import PurgeDialog
 from View.Geometry.Translate import GeometryTranslate
 from View.Geometry.Profile.Window import ProfileWindow
@@ -97,7 +97,6 @@ class GeometryWindow(PamhyrWindow):
         self.setup_plots()
         self.setup_statusbar()
         self.setup_connections()
-        self.changed_slider_value()
 
     def setup_table(self):
         table_headers = self._trad.get_dict("table_headers")
@@ -106,7 +105,7 @@ class GeometryWindow(PamhyrWindow):
         self._table = GeometryReachTableModel(
             table_view=table,
             table_headers=table_headers,
-            editable_headers=["name", "kp"],
+            editable_headers=["name", "rk"],
             data=self._reach,
             undo=self._undo_stack
         )
@@ -117,7 +116,7 @@ class GeometryWindow(PamhyrWindow):
 
     def setup_plots(self):
         self.setup_plots_xy()
-        self.setup_plots_kpc()
+        self.setup_plots_rkc()
         self.setup_plots_ac()
 
     def setup_plots_xy(self):
@@ -132,17 +131,17 @@ class GeometryWindow(PamhyrWindow):
         self._plot_layout_xy.addWidget(self._canvas_xy)
         self.plot_xy()
 
-    def setup_plots_kpc(self):
+    def setup_plots_rkc(self):
-        self._canvas_kpc = MplCanvas(width=6, height=4, dpi=100)
+        self._canvas_rkc = MplCanvas(width=6, height=4, dpi=100)
-        self._canvas_kpc.setObjectName("canvas_kpc")
+        self._canvas_rkc.setObjectName("canvas_rkc")
-        self._toolbar_kpc = PamhyrPlotToolbar(
+        self._toolbar_rkc = PamhyrPlotToolbar(
-            self._canvas_kpc, self,
+            self._canvas_rkc, self,
             items=["home", "zoom", "save", "iso", "back/forward", "move"]
         )
-        self._plot_layout_kpc = self.find(QVBoxLayout, "verticalLayout_2")
+        self._plot_layout_rkc = self.find(QVBoxLayout, "verticalLayout_2")
-        self._plot_layout_kpc.addWidget(self._toolbar_kpc)
+        self._plot_layout_rkc.addWidget(self._toolbar_rkc)
-        self._plot_layout_kpc.addWidget(self._canvas_kpc)
+        self._plot_layout_rkc.addWidget(self._canvas_rkc)
-        self.plot_kpc()
+        self.plot_rkc()
 
     def setup_plots_ac(self):
         self._canvas_ac = MplCanvas(width=9, height=4, dpi=100)
@@ -163,7 +162,7 @@ class GeometryWindow(PamhyrWindow):
 
         profile = self._reach.profile(row)
 
-        name = profile.name + " " + str(profile.kp)
+        name = profile.name + " " + str(profile.rk)
 
         return (
             "<font color=\"Grey\">" +
@@ -193,7 +192,7 @@ class GeometryWindow(PamhyrWindow):
             "action_delete": self.delete,
             "action_edit": self.edit_profile,
             "action_meshing": self.edit_meshing,
-            "action_update_kp": self.update_kp,
+            "action_update_rk": self.update_rk,
             "action_purge": self.purge,
         }
 
@@ -201,13 +200,6 @@ class GeometryWindow(PamhyrWindow):
             self.find(QAction, action)\
                 .triggered.connect(actions[action])
 
-        self.find(QSlider, "verticalSlider").valueChanged.connect(
-            self.changed_slider_value)
-        self.find(QPushButton, "pushButton_up").clicked.connect(
-            self.decrement_value_slider)
-        self.find(QPushButton, "pushButton_down").clicked.connect(
-            self.increment_value_slider)
-
         # Profile selection when line change in table
         self.find(QTableView, "tableView").selectionModel()\
                                           .selectionChanged\
@@ -224,11 +216,10 @@ class GeometryWindow(PamhyrWindow):
     def _update(self, redraw=False, propagate=True):
         if redraw:
             self._plot_xy.draw()
-            self._plot_kpc.draw()
+            self._plot_rkc.draw()
             self._plot_ac.draw()
 
         self.select_current_profile()
-        self.changed_slider_value()
 
         if propagate:
             self._propagate_update(key=Modules.GEOMETRY)
@@ -324,9 +315,9 @@ class GeometryWindow(PamhyrWindow):
                 src_except=e
             )
 
-    def update_kp(self):
+    def update_rk(self):
         try:
-            dlg = UpdateKPDialog(
+            dlg = UpdateRKDialog(
                 reach=self._reach,
                 trad=self._trad,
                 parent=self
@@ -336,16 +327,17 @@ class GeometryWindow(PamhyrWindow):
                     "origin": dlg.origin,
                     "directrices": [dlg.begin_dir, dlg.end_dir],
                     "origin_value": dlg.origin_value,
+                    "orientation": dlg.orientation,
                 }
-                self._update_kp(data)
+                self._update_rk(data)
         except Exception as e:
             logger_exception(e)
             return
 
-    def _update_kp(self, data):
+    def _update_rk(self, data):
         try:
             mesher = MeshingWithMageMailleurTT()
-            self._table.update_kp(mesher, data)
+            self._table.update_rk(mesher, data)
         except Exception as e:
             logger_exception(e)
             raise ExternFileMissingError(
@@ -362,7 +354,9 @@ class GeometryWindow(PamhyrWindow):
             canvas=self._canvas_xy,
             data=self._reach,
             trad=self._trad,
-            toolbar=self._toolbar_xy
+            toolbar=self._toolbar_xy,
+            table=self.find(QTableView, "tableView"),
+            parent=self
         )
         self._plot_xy.draw()
 
@@ -373,23 +367,25 @@ class GeometryWindow(PamhyrWindow):
         self._plot_xy.update()
         self.tableView.model().blockSignals(False)
 
-    def plot_kpc(self):
+    def plot_rkc(self):
         self.tableView.model().blockSignals(True)
 
-        self._plot_kpc = PlotKPZ(
+        self._plot_rkc = PlotRKZ(
-            canvas=self._canvas_kpc,
+            canvas=self._canvas_rkc,
             study=self._study,
             data=self._reach,
             trad=self._trad,
-            toolbar=self._toolbar_kpc
+            toolbar=self._toolbar_rkc,
+            table=self.find(QTableView, "tableView"),
+            parent=self
         )
-        self._plot_kpc.draw()
+        self._plot_rkc.draw()
 
         self.tableView.model().blockSignals(False)
 
-    def update_plot_kpc(self):
+    def update_plot_rkc(self):
         self.tableView.model().blockSignals(True)
-        self._plot_kpc.update()
+        self._plot_rkc.update()
         self.tableView.model().blockSignals(False)
 
     def plot_ac(self):
@@ -422,10 +418,10 @@ class GeometryWindow(PamhyrWindow):
         self._plot_xy.update()
         self.tableView.model().blockSignals(False)
 
-    def select_plot_kpc(self, ind: int):
+    def select_plot_rkc(self, ind: int):
         self.tableView.model().blockSignals(True)
-        self._plot_kpc.current = ind
+        self._plot_rkc.current = ind
-        self._plot_kpc.update()
+        self._plot_rkc.update()
         self.tableView.model().blockSignals(False)
 
     def select_plot_ac(self, ind: int):
@@ -434,63 +430,21 @@ class GeometryWindow(PamhyrWindow):
         self._plot_ac.update()
         self.tableView.model().blockSignals(False)
 
-    def select_row_profile_slider(self, ind: int = 0):
-        if self.tableView is not None:
-            selectionModel = self.tableView.selectionModel()
-            index = self.tableView.model().index(ind, 0)
-
-            selectionModel.select(
-                index,
-                QItemSelectionModel.Rows |
-                QItemSelectionModel.ClearAndSelect |
-                QItemSelectionModel.Select
-            )
-
-            self.tableView.scrollTo(index)
-
     def select_current_profile(self):
         self.tableView.model().blockSignals(True)
         row = self.index_selected_row()
 
         if row is not None:
-            self.find(QSlider, "verticalSlider").setValue(row)
             self.select_plot_xy(row)
-            self.select_plot_kpc(row)
+            self.select_plot_rkc(row)
             self.select_plot_ac(row)
         else:
             self._plot_xy.draw()
-            self._plot_kpc.draw()
+            self._plot_rkc.draw()
             self._plot_ac.draw()
 
         self.tableView.model().blockSignals(False)
 
-    def changed_slider_value(self):
-        self.tableView.model().blockSignals(True)
-
-        if self._table.rowCount() != 0:
-            slider = self.find(QSlider, "verticalSlider")
-            slider.setMaximum(self._table.rowCount() - 1)
-
-            slider_value = slider.value()
-            kp = self._reach.profile(slider_value).kp
-
-            self.select_plot_xy(slider_value)
-            self.select_plot_kpc(slider_value)
-            self.select_row_profile_slider(slider_value)
-            self.update_statusbar()
-
-        self.tableView.model().blockSignals(False)
-
-    def increment_value_slider(self):
-        slider = self.find(QSlider, "verticalSlider")
-        if 0 <= slider.value() < self._table.rowCount() - 1:
-            slider.setValue(slider.value() + 1)
-
-    def decrement_value_slider(self):
-        slider = self.find(QSlider, "verticalSlider")
-        if 0 < slider.value() < self._table.rowCount():
-            slider.setValue(slider.value() - 1)
-
     def add(self):
         if len(self.tableView.selectedIndexes()) == 0:
             self._table.add(self._table.rowCount())
@@ -515,7 +469,7 @@ class GeometryWindow(PamhyrWindow):
                 .selectionModel()\
                 .selectedRows()
 
-        if len(r) > 0:
+        if len(r) == 1:
             return r[0].row()
         else:
             return None
@@ -523,13 +477,11 @@ class GeometryWindow(PamhyrWindow):
     def sort_ascending(self):
         self._table.sort_profiles(False)
         self.select_current_profile()
-        self.changed_slider_value()
 
     def sort_descending(self):
         self._table.sort_profiles(True)
 
         self.select_current_profile()
-        self.changed_slider_value()
 
     def move_up(self):
         row = self.index_selected_row()
@@ -587,12 +539,12 @@ class GeometryWindow(PamhyrWindow):
                    .selectedRows()
 
         table = []
-        # table.append(["name", "kp"])
+        # table.append(["name", "rk"])
 
         for row in rows:
             profile = self._reach.profile(row.row())
             table.append(
-                [profile.name, profile.kp]
+                [profile.name, profile.rk]
             )
 
         self.copyTableIntoClipboard(table)
@@ -636,14 +588,14 @@ class GeometryWindow(PamhyrWindow):
         self.select_current_profile()
         # self.update_plot_ac()
         # self.update_plot_xy()
-        # self.update_plot_kpc()
+        # self.update_plot_rkc()
 
     def _redo(self):
         self._table.redo()
         self.select_current_profile()
         # self.update_plot_ac()
         # self.update_plot_xy()
-        # self.update_plot_kpc()
+        # self.update_plot_rkc()
 
     def export_to_file(self):
         settings = QSettings(
@@ -690,13 +642,13 @@ class GeometryWindow(PamhyrWindow):
         c1 = f"{profile.code1:>6}"
         c2 = f"{profile.code2:>6}"
         t = f"{len(profile.points):>6}"
-        kp = f"{profile.kp:>12f}"[0:12]
+        rk = f"{profile.rk:>12f}"[0:12]
         pname = profile.name
         if profile.name == "":
             pname = f"p{profile.id:>3}".replace(" ", "0")
             name = f"{pname:<19}"
 
-        wfile.write(f"{num}{c1}{c2}{t} {kp} {pname}\n")
+        wfile.write(f"{num}{c1}{c2}{t} {rk} {pname}\n")
 
         for point in profile.points:
             self._export_to_file_st_point(wfile, point)

src/View/HydraulicStructures/BasicHydraulicStructures/Window.py

@@ -150,9 +150,9 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
         self.plot_layout.addWidget(self.canvas)
 
         reach = self._hs.input_reach
-        profile_kp = self._hs.input_kp
+        profile_rk = self._hs.input_rk
-        if profile_kp is not None:
+        if profile_rk is not None:
-            profiles = reach.reach.get_profiles_from_kp(float(profile_kp))
+            profiles = reach.reach.get_profiles_from_rk(float(profile_rk))
         else:
             profiles = None
         if profiles is not None:

src/View/HydraulicStructures/PlotAC.py

@@ -57,11 +57,11 @@ class PlotAC(PamhyrPlot):
         self.init_axes()
 
         if self.data is None:
-            self.line_kp = None
+            self.line_rk = None
             return
 
         if self._current_reach is None:
-            self.line_kp = None
+            self.line_rk = None
             return
 
         self.draw_data()
@@ -73,13 +73,13 @@ class PlotAC(PamhyrPlot):
         reach = self._current_reach
 
         if self._current_profile is None:
-            self.line_kp = None
+            self.line_rk = None
         else:
             profile = self._current_profile
             x = profile.get_station()
             z = profile.z()
 
-            self.line_kp, = self.canvas.axes.plot(
+            self.line_rk, = self.canvas.axes.plot(
                 x, z,
                 color=self.color_plot_river_bottom,
                 **self.plot_default_kargs
@@ -94,7 +94,7 @@ class PlotAC(PamhyrPlot):
         self.update()
 
     def update(self):
-        if self.line_kp is None:
+        if self.line_rk is None:
             self.draw()
             return
 
@@ -110,11 +110,11 @@ class PlotAC(PamhyrPlot):
         x = profile.get_station()
         z = profile.z()
 
-        self.line_kp.set_data(x, z)
+        self.line_rk.set_data(x, z)
 
     def clear(self):
         self.update_clear()
 
     def update_clear(self):
-        if self.line_kp is not None:
+        if self.line_rk is not None:
-            self.line_kp.set_data([], [])
+            self.line_rk.set_data([], [])

src/View/HydraulicStructures/PlotRKC.py

@@ -1,4 +1,4 @@
-# PlotKPC.py -- Pamhyr
+# PlotRKC.py -- Pamhyr
 # Copyright (C) 2023-2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -20,19 +20,20 @@ from tools import timer
 from View.Tools.PamhyrPlot import PamhyrPlot
 
 from PyQt5.QtCore import (
-    QCoreApplication
+    QCoreApplication, Qt,
 )
+from PyQt5.QtWidgets import QApplication
 
 from matplotlib.collections import LineCollection
 
 _translate = QCoreApplication.translate
 
 
-class PlotKPC(PamhyrPlot):
+class PlotRKC(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
                  river=None, reach=None, profile=None,
                  parent=None):
-        super(PlotKPC, self).__init__(
+        super(PlotRKC, self).__init__(
             canvas=canvas,
             trad=trad,
             data=river,
@@ -43,13 +44,14 @@ class PlotKPC(PamhyrPlot):
         self._current_reach = reach
         self._current_profile = profile
 
-        self.label_x = self._trad["unit_kp"]
+        self.label_x = self._trad["unit_rk"]
         self.label_y = self._trad["unit_elevation"]
 
         self._isometric_axis = False
 
         self._auto_relim_update = True
         self._autoscale_update = True
+        self.parent = parent
 
     @property
     def river(self):
@@ -65,14 +67,14 @@ class PlotKPC(PamhyrPlot):
 
         if self.data is None:
             self.profile = None
-            self.line_kp_zmin_zmax = None
+            self.line_rk_zmin_zmax = None
-            self.line_kp_zmin = None
+            self.line_rk_zmin = None
             return
 
         if self._current_reach is None:
             self.profile = None
-            self.line_kp_zmin_zmax = None
+            self.line_rk_zmin_zmax = None
-            self.line_kp_zmin = None
+            self.line_rk_zmin = None
             return
 
         self.draw_data()
@@ -84,35 +86,43 @@ class PlotKPC(PamhyrPlot):
     def draw_data(self):
         reach = self._current_reach
 
-        kp = reach.reach.get_kp()
+        rk = reach.reach.get_rk()
         z_min = reach.reach.get_z_min()
         z_max = reach.reach.get_z_max()
 
-        self.line_kp_zmin, = self.canvas.axes.plot(
+        self.line_rk_zmin, = self.canvas.axes.plot(
-            kp, z_min,
+            rk, z_min,
             color=self.color_plot_river_bottom,
-            lw=1.
+            lw=1.,
         )
 
-        if len(kp) != 0:
+        self.line_rk_zmax, = self.canvas.axes.plot(
-            self.line_kp_zmin_zmax = self.canvas.axes.vlines(
+            rk, z_max,
-                x=kp,
+            color=self.color_plot_river_bottom,
+            lw=1.,
+            alpha=0.0
+        )
+
+        if len(rk) != 0:
+            self.line_rk_zmin_zmax = self.canvas.axes.vlines(
+                x=rk,
                 ymin=z_min, ymax=z_max,
                 color=self.color_plot,
-                lw=1.
+                lw=1.,
+                picker=10
             )
 
     def draw_current(self):
         if self._current_profile is None:
             self.profile = None
         else:
-            kp = [self._current_profile.kp,
+            rk = [self._current_profile.rk,
-                  self._current_profile.kp]
+                  self._current_profile.rk]
             min_max = [self._current_profile.z_min(),
                        self._current_profile.z_max()]
 
             self.profile = self.canvas.axes.plot(
-                kp, min_max,
+                rk, min_max,
                 color=self.color_plot_current,
                 lw=1.
             )
@@ -131,7 +141,7 @@ class PlotKPC(PamhyrPlot):
 
     def update_current_profile(self):
         reach = self._current_reach
-        kp = reach.reach.get_kp()
+        rk = reach.reach.get_rk()
         z_min = reach.reach.get_z_min()
         z_max = reach.reach.get_z_max()
 
@@ -139,7 +149,7 @@ class PlotKPC(PamhyrPlot):
             self.draw()
         else:
             self.profile.set_data(
-                [self._current_profile.kp, self._current_profile.kp],
+                [self._current_profile.rk, self._current_profile.rk],
                 [self._current_profile.z_min(), self._current_profile.z_max()],
             )
 
@@ -149,12 +159,12 @@ class PlotKPC(PamhyrPlot):
         if self.profile is not None:
             self.profile[0].set_data([], [])
 
-        if self.line_kp_zmin_zmax is not None:
+        if self.line_rk_zmin_zmax is not None:
-            self.line_kp_zmin_zmax.remove()
+            self.line_rk_zmin_zmax.remove()
-            self.line_kp_zmin_zmax = None
+            self.line_rk_zmin_zmax = None
 
-        if self.line_kp_zmin is not None:
+        if self.line_rk_zmin is not None:
-            self.line_kp_zmin.set_data([], [])
+            self.line_rk_zmin.set_data([], [])
 
         self.canvas.figure.canvas.draw_idle()
 
@@ -163,3 +173,40 @@ class PlotKPC(PamhyrPlot):
             self.profile.set_data([], [])
 
         self.canvas.figure.canvas.draw_idle()
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        closest = self._closest_profile(event)
+        index = self.parent.tableView.selectedIndexes()
+        if self.parent._table is not None:
+            self.parent._table.setData(index[2], closest)
+
+        return
+
+    def _closest_profile(self, event):
+
+        s = event.artist.get_segments()
+        x = [i[0, 0] for i in s]
+        mx = event.mouseevent.xdata
+        points = enumerate(x)
+
+        def dist_mouse(point):
+            x = point[1]
+            d = abs(mx - x)
+            return d
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest[1]

src/View/HydraulicStructures/Table.py

@@ -37,7 +37,7 @@ from PyQt5.QtWidgets import (
 from View.Tools.PamhyrTable import PamhyrTableModel
 
 from View.HydraulicStructures.UndoCommand import (
-    SetNameCommand, SetReachCommand, SetKpCommand,
+    SetNameCommand, SetReachCommand, SetRkCommand,
     SetEnabledCommand, AddCommand, DelCommand,
 )
 
@@ -58,14 +58,14 @@ class ComboBoxDelegate(QItemDelegate):
         self.editor = QComboBox(parent)
 
         val = []
-        if self._mode == "kp":
+        if self._mode == "rk":
             reach = self._data.hydraulic_structures\
                               .get(index.row())\
                               .input_reach
             if reach is not None:
                 val = list(
                     map(
-                        lambda kp: str(kp), reach.reach.get_kp()
+                        lambda rk: str(rk), reach.reach.get_rk()
                     )
                 )
         else:
@@ -126,8 +126,8 @@ class TableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return n.name
-        elif self._headers[column] == "kp":
+        elif self._headers[column] == "rk":
-            n = self._lst.get(row).input_kp
+            n = self._lst.get(row).input_rk
             if n is None:
                 return self._trad['not_associated']
             return n
@@ -158,12 +158,12 @@ class TableModel(PamhyrTableModel):
                         self._lst, row, self._data.edge(value)
                     )
                 )
-            elif self._headers[column] == "kp":
+            elif self._headers[column] == "rk":
                 if value == na:
                     value = None
 
                 self._undo.push(
-                    SetKpCommand(
+                    SetRkCommand(
                         self._lst, row, value
                     )
                 )

src/View/HydraulicStructures/Translate.py

@@ -36,5 +36,5 @@ class HydraulicStructuresTranslate(MainTranslate):
         self._sub_dict["table_headers"] = {
             "name": self._dict["name"],
             "reach": self._dict["reach"],
-            "kp": self._dict["unit_kp"],
+            "rk": self._dict["unit_rk"],
         }

src/View/HydraulicStructures/UndoCommand.py

@@ -52,34 +52,34 @@ class SetReachCommand(QUndoCommand):
         self._index = index
         self._old = self._h_s_lst.get(self._index).input_reach
         self._new = reach
-        self._old_kp = self._h_s_lst.get(self._index).input_kp
+        self._old_rk = self._h_s_lst.get(self._index).input_rk
-        self._new_kp = None
+        self._new_rk = None
 
     def undo(self):
         i = self._h_s_lst.get(self._index)
         i.input_reach = self._old
-        i.input_kp = self._old_kp
+        i.input_rk = self._old_rk
 
     def redo(self):
         i = self._h_s_lst.get(self._index)
         i.input_reach = self._new
-        i.input_kp = self._new_kp
+        i.input_rk = self._new_rk
 
 
-class SetKpCommand(QUndoCommand):
+class SetRkCommand(QUndoCommand):
-    def __init__(self, h_s_lst, index, kp):
+    def __init__(self, h_s_lst, index, rk):
         QUndoCommand.__init__(self)
 
         self._h_s_lst = h_s_lst
         self._index = index
-        self._old = self._h_s_lst.get(self._index).input_kp
+        self._old = self._h_s_lst.get(self._index).input_rk
-        self._new = kp
+        self._new = rk
 
     def undo(self):
-        self._h_s_lst.get(self._index).input_kp = self._old
+        self._h_s_lst.get(self._index).input_rk = self._old
 
     def redo(self):
-        self._h_s_lst.get(self._index).input_kp = self._new
+        self._h_s_lst.get(self._index).input_rk = self._new
 
 
 class SetEnabledCommand(QUndoCommand):

src/View/HydraulicStructures/Window.py

@@ -39,7 +39,7 @@ from View.Tools.Plot.PamhyrCanvas import MplCanvas
 from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 
 from View.HydraulicStructures.PlotAC import PlotAC
-from View.HydraulicStructures.PlotKPC import PlotKPC
+from View.HydraulicStructures.PlotRKC import PlotRKC
 
 from View.HydraulicStructures.Table import (
     TableModel, ComboBoxDelegate
@@ -89,21 +89,21 @@ class HydraulicStructuresWindow(PamhyrWindow):
             parent=self,
             mode="reaches"
         )
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             trad=self._trad,
             data=self._study.river,
             parent=self,
-            mode="kp"
+            mode="rk"
         )
 
         table = self.find(QTableView, f"tableView")
         self._table = TableModel(
             table_view=table,
             table_headers=self._trad.get_dict("table_headers"),
-            editable_headers=["name", "reach", "kp"],
+            editable_headers=["name", "reach", "rk"],
             delegates={
                 "reach": self._delegate_reach,
-                "kp": self._delegate_kp,
+                "rk": self._delegate_rk,
             },
             trad=self._trad,
             data=self._study.river,
@@ -135,15 +135,16 @@ class HydraulicStructuresWindow(PamhyrWindow):
         self.plot_layout.addWidget(self.toolbar)
         self.plot_layout.addWidget(self.canvas)
 
-        self.plot_kpc = PlotKPC(
+        self.plot_rkc = PlotRKC(
             canvas=self.canvas,
             river=self._study.river,
             reach=None,
             profile=None,
             trad=self._trad,
-            toolbar=self.toolbar
+            toolbar=self.toolbar,
+            parent=self
         )
-        self.plot_kpc.draw()
+        self.plot_rkc.draw()
 
         self.canvas_2 = MplCanvas(width=5, height=4, dpi=100)
         self.canvas_2.setObjectName("canvas_2")
@@ -284,20 +285,20 @@ class HydraulicStructuresWindow(PamhyrWindow):
 
         reach = self._hs_lst.get(rows[0]).input_reach
         if reach is not None:
-            self.plot_kpc.set_reach(reach)
+            self.plot_rkc.set_reach(reach)
             self.plot_ac.set_reach(reach)
 
-            profile_kp = self._hs_lst.get(rows[0]).input_kp
+            profile_rk = self._hs_lst.get(rows[0]).input_rk
-            if profile_kp is not None:
+            if profile_rk is not None:
                 profiles = reach.reach\
-                                .get_profiles_from_kp(
+                                .get_profiles_from_rk(
-                                    float(profile_kp)
+                                    float(profile_rk)
                                 )
 
                 if len(profiles) != 0 and profiles is not None:
                     profile = profiles[0]
 
-                    self.plot_kpc.set_profile(profile)
+                    self.plot_rkc.set_profile(profile)
                     self.plot_ac.set_profile(profile)
                 else:
                     self._update_clear_profile()
@@ -307,9 +308,9 @@ class HydraulicStructuresWindow(PamhyrWindow):
             self._update_clear_all()
 
     def _update_clear_all(self):
-        self.plot_kpc.clear()
+        self.plot_rkc.clear()
         self.plot_ac.clear()
 
     def _update_clear_profile(self):
         self.plot_ac.clear()
-        self.plot_kpc.clear_profile()
+        self.plot_rkc.clear_profile()

src/View/InitialConditions/PlotDRK.py

@@ -1,4 +1,4 @@
-# PlotDKP.py -- Pamhyr
+# PlotDRK.py -- Pamhyr
 # Copyright (C) 2023-2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,10 +30,10 @@ logger = logging.getLogger()
 _translate = QCoreApplication.translate
 
 
-class PlotDKP(PamhyrPlot):
+class PlotDRK(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
                  data=None, parent=None):
-        super(PlotDKP, self).__init__(
+        super(PlotDRK, self).__init__(
             canvas=canvas,
             trad=trad,
             data=data,
@@ -41,7 +41,7 @@ class PlotDKP(PamhyrPlot):
             parent=parent
         )
 
-        self.label_x = self._trad["kp"]
+        self.label_x = self._trad["rk"]
         self.label_y = self._trad["elevation"]
 
         self._isometric_axis = False
@@ -63,41 +63,41 @@ class PlotDKP(PamhyrPlot):
         self._init = True
 
     def draw_river_bottom(self):
-        kp = self.data.reach.reach.get_kp()
+        rk = self.data.reach.reach.get_rk()
         z_min = self.data.reach.reach.get_z_min()
 
-        self.line_kp_zmin = self.canvas.axes.plot(
+        self.line_rk_zmin = self.canvas.axes.plot(
-            kp, z_min,
+            rk, z_min,
             color=self.color_plot_river_bottom,
             lw=1.
         )
 
     def draw_water(self):
         if len(self.data) != 0:
-            kp = self.data.get_kp()
+            rk = self.data.get_rk()
             elevation = self.data.get_elevation()
 
-            self.line_kp_elevation = self.canvas.axes.plot(
+            self.line_rk_elevation = self.canvas.axes.plot(
-                kp, elevation,
+                rk, elevation,
                 color=self.color_plot_river_water,
                 **self.plot_default_kargs
             )
 
             z_min = self.data.reach.reach.get_z_min()
-            geometry_kp = self.data.reach.reach.get_kp()
+            geometry_rk = self.data.reach.reach.get_rk()
 
             filtred_elevation = list(
                 map(
                     lambda x: elevation[x[0]],
                     filter(
-                        lambda x: x[1] in geometry_kp,
+                        lambda x: x[1] in geometry_rk,
-                        enumerate(kp)
+                        enumerate(rk)
                     )
                 )
             )
 
             self.collection = self.canvas.axes.fill_between(
-                geometry_kp, z_min, filtred_elevation,
+                geometry_rk, z_min, filtred_elevation,
                 color=self.color_plot_river_water_zone,
                 alpha=0.7, interpolate=True
             )

src/View/InitialConditions/PlotDischarge.py

@@ -31,7 +31,7 @@ class PlotDischarge(PamhyrPlot):
             parent=parent
         )
 
-        self.label_x = self._trad["kp"]
+        self.label_x = self._trad["rk"]
         self.label_y = self._trad["discharge"]
 
         self._isometric_axis = False
@@ -55,11 +55,11 @@ class PlotDischarge(PamhyrPlot):
         self.line_discharge = []
 
         if len(self.data) != 0:
-            kp = self.data.get_kp()
+            rk = self.data.get_rk()
             discharge = self.data.get_discharge()
 
             line, = self.canvas.axes.plot(
-                kp, discharge,
+                rk, discharge,
                 color=self.color_plot,
                 **self.plot_default_kargs
             )
@@ -76,11 +76,11 @@ class PlotDischarge(PamhyrPlot):
 
     def update_data(self):
         if len(self.data) == len(self.line_discharge):
-            kp = self.data.get_kp()
+            rk = self.data.get_rk()
             discharge = self.data.get_discharge()
 
             line, = self.canvas.axes.plot(
-                kp, discharge,
+                rk, discharge,
                 color=self.color_plot,
                 **self.plot_default_kargs
             )

src/View/InitialConditions/Table.py

@@ -59,7 +59,7 @@ class ComboBoxDelegate(QItemDelegate):
             list(
                 map(
                     str,
-                    self._reach.get_kp()
+                    self._reach.get_rk()
                 )
             )
         )
@@ -107,8 +107,8 @@ class InitialConditionTableModel(PamhyrTableModel):
         if self._headers[column] is "speed":
             z = self._lst.get(row)["elevation"]
             q = self._lst.get(row)["discharge"]
-            profile = self._reach.reach.get_profiles_from_kp(
+            profile = self._reach.reach.get_profiles_from_rk(
-                self._lst.get(row)["kp"]
+                self._lst.get(row)["rk"]
             )
             if len(profile) >= 1:
                 speed = profile[0].speed(q, z)
@@ -258,7 +258,7 @@ class InitialConditionTableModel(PamhyrTableModel):
         data = list(
             map(
                 lambda p: [
-                    p.geometry.kp,
+                    p.geometry.rk,
                     p.get_ts_key(ts, "Q"),
                     p.get_ts_key(ts, "Z"),
                 ],

src/View/InitialConditions/UndoCommand.py

@@ -106,7 +106,7 @@ class SortCommand(QUndoCommand):
     def redo(self):
         self._ics.sort(
             reverse=self._reverse,
-            key=lambda x: x["kp"]
+            key=lambda x: x["rk"]
         )
         if self._indexes is None:
             self._indexes = list(

src/View/InitialConditions/Window.py

@@ -55,7 +55,7 @@ from View.InitialConditions.Table import (
 from View.Tools.Plot.PamhyrCanvas import MplCanvas
 from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 
-from View.InitialConditions.PlotDKP import PlotDKP
+from View.InitialConditions.PlotDRK import PlotDRK
 from View.InitialConditions.PlotDischarge import PlotDischarge
 from View.InitialConditions.translate import ICTranslate
 from View.InitialConditions.DialogHeight import HeightDialog
@@ -108,7 +108,7 @@ class InitialConditionsWindow(PamhyrWindow):
 
     def setup_table(self):
         table = self.find(QTableView, f"tableView")
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             reach=self._reach,
             parent=self
         )
@@ -117,8 +117,8 @@ class InitialConditionsWindow(PamhyrWindow):
             reach=self._reach,
             table_view=table,
             table_headers=self._trad.get_dict("table_headers"),
-            editable_headers=["kp", "discharge", "elevation", "height"],
+            editable_headers=["rk", "discharge", "elevation", "height"],
-            delegates={"kp": self._delegate_kp},
+            delegates={"rk": self._delegate_rk},
             data=self._study,
             undo=self._undo_stack,
             trad=self._trad
@@ -139,7 +139,7 @@ class InitialConditionsWindow(PamhyrWindow):
         self.plot_layout_1.addWidget(self.toolbar_1)
         self.plot_layout_1.addWidget(self.canvas_1)
 
-        self.plot_1 = PlotDKP(
+        self.plot_1 = PlotDRK(
             canvas=self.canvas_1,
             data=self._ics,
             trad=self._trad,
@@ -304,7 +304,7 @@ class InitialConditionsWindow(PamhyrWindow):
                 lambda eic: list(
                     map(
                         lambda k: eic[1][k],
-                        ["kp", "discharge", "elevation"]
+                        ["rk", "discharge", "elevation"]
                     )
                 ),
                 filter(

src/View/InitialConditions/translate.py

@@ -36,11 +36,11 @@ class ICTranslate(MainTranslate):
 
         self._dict["elevation"] = self._dict["unit_elevation"]
         self._dict["discharge"] = self._dict["unit_discharge"]
-        self._dict["kp"] = self._dict["unit_kp"]
+        self._dict["rk"] = self._dict["unit_rk"]
 
         self._sub_dict["table_headers"] = {
             # "name": _translate("InitialCondition", "Name"),
-            "kp": self._dict["unit_kp"],
+            "rk": self._dict["unit_rk"],
             "discharge": self._dict["unit_discharge"],
             "elevation": self._dict["unit_elevation"],
             "height": self._dict["unit_height"],

src/View/LateralContribution/Edit/Table.py

@@ -99,7 +99,7 @@ class TableModel(PamhyrTableModel):
             logger.info(e)
             logger.debug(traceback.format_exc())
 
-        self.dataChanged.emit(index, index)
+        self.update()
         return True
 
     def add(self, row, parent=QModelIndex()):
@@ -112,7 +112,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endInsertRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def delete(self, rows, parent=QModelIndex()):
         self.beginRemoveRows(parent, rows[0], rows[-1])
@@ -135,7 +135,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.layoutAboutToBeChanged.emit()
-        self.layoutChanged.emit()
+        self.update()
 
     def move_up(self, row, parent=QModelIndex()):
         if row <= 0:
@@ -152,7 +152,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def move_down(self, index, parent=QModelIndex()):
         if row > len(self._data):
@@ -169,7 +169,7 @@ class TableModel(PamhyrTableModel):
         )
 
         self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()
 
     def paste(self, row, header, data):
         if len(data) == 0:
@@ -190,4 +190,13 @@ class TableModel(PamhyrTableModel):
         )
 
         self.layoutAboutToBeChanged.emit()
+        self.update()
+
+    def auto_sort(self):
+        self.layoutAboutToBeChanged.emit()
+        self._data.sort(key=lambda x: x[0])
+        self.layoutAboutToBeChanged.emit()
+
+    def update(self):
+        # self.auto_sort()
         self.layoutChanged.emit()

src/View/LateralContribution/Edit/Window.py

@@ -137,6 +137,7 @@ class EditLateralContributionWindow(PamhyrWindow):
         self.find(QAction, "action_sort").triggered.connect(self.sort)
 
         self._table.dataChanged.connect(self.update)
+        self._table.layoutChanged.connect(self.update)
 
     def update(self):
         self.plot.update()

src/View/LateralContribution/PlotXY.py

@@ -0,0 +1,260 @@
+# PlotXY.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from tools import timer, trace
+from View.Tools.PamhyrPlot import PamhyrPlot
+from matplotlib import collections
+import numpy as np
+
+from PyQt5.QtCore import (
+    QCoreApplication, Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
+)
+from PyQt5.QtWidgets import QApplication, QTableView
+
+_translate = QCoreApplication.translate
+
+
+class PlotXY(PamhyrPlot):
+    def __init__(self, canvas=None, trad=None, data=None, toolbar=None,
+                 table=None, parent=None):
+        super(PlotXY, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=data,
+            toolbar=toolbar,
+            table=table,
+            parent=parent
+        )
+
+        self.line_xy = []
+        self.line_gl = []
+
+        self.label_x = self._trad["x"]
+        self.label_y = self._trad["y"]
+
+        self.before_plot_selected = None
+        self.plot_selected = None
+        self.after_plot_selected = None
+        self.parent = parent
+        self.line_xy_collection = None
+        self._table = table
+        self._colors = []
+        self._style = []
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value not in [1, 3]:
+            return
+
+        closest = self._closest_section(event)
+        t = self.parent.current_tab()
+        tableView = self.parent.find(QTableView, f"tableView_{t}")
+        table = self.parent._table[t]
+        index = tableView.selectedIndexes()
+        rk = self.data.get_rk()
+        if self.parent._table is not None:
+            if event.mouseevent.button.value == 1:
+                table.setData(index[3], rk[closest[0]])
+            if event.mouseevent.button.value == 3:
+                table.setData(index[4], rk[closest[0]])
+
+        return
+
+    def _closest_section(self, event):
+        axes = self.canvas.axes
+        mx = event.mouseevent.xdata
+        my = event.mouseevent.ydata
+        bx, by = axes.get_xlim(), axes.get_ylim()
+        ratio = (bx[0] - bx[1]) / (by[0] - by[1])
+
+        segments = event.artist.get_segments()
+        ind = event.ind
+
+        points = []
+        for i in ind:
+            points = points + [[i, j] for j in segments[i]]
+
+        def dist_mouse(point):
+            x, y = point[1]
+            d2 = (((mx - x) / ratio) ** 2) + ((my - y) ** 2)
+            return d2
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    @timer
+    def draw(self):
+        self.init_axes()
+
+        if self.data is None:
+            self.idle()
+            return
+
+        if self.data.number_profiles == 0:
+            self._init = False
+            self.idle()
+            return
+
+        self.draw_xy()
+        self.draw_lr()
+        self.draw_gl()
+
+        self.idle()
+        self._init = True
+
+    def draw_xy(self):
+        self.line_xy = []
+        for xy in zip(self.data.get_x(), self.data.get_y()):
+            self.line_xy.append(np.column_stack(xy))
+
+        self._colors, self._style = self.color_hightlight()
+        self.line_xy_collection = collections.LineCollection(
+                self.line_xy,
+                colors=self._colors,
+                linestyle=self._style,
+                picker=10
+            )
+        self.canvas.axes.add_collection(self.line_xy_collection)
+
+    def color_hightlight(self):
+        rk_min, rk_max = (-1, -1)
+        if self._highlight_data is not None:
+            rk_min, rk_max = self._highlight_data
+
+        colors = [self.color_plot for row in range(len(self._data))]
+        for i, rk in enumerate(self.data.get_rk_complete_profiles()):
+            if rk_min <= rk <= rk_max:
+                colors[i] = self.color_plot_current
+        style = ["-" for row in range(len(self._data))]
+
+        return colors, style
+
+    def draw_lr(self):
+        lx = []
+        ly = []
+        rx = []
+        ry = []
+
+        self.line_lr = []
+        for x, y in zip(self.data.get_x(),
+                        self.data.get_y()):
+            lx.append(x[0])
+            ly.append(y[0])
+
+            rx.append(x[-1])
+            ry.append(y[-1])
+
+        line = self.canvas.axes.plot(
+            lx, ly,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+        line = self.canvas.axes.plot(
+            rx, ry,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+    def draw_gl(self):
+        x_complete = self.data.get_guidelines_x()
+        y_complete = self.data.get_guidelines_y()
+
+        ind = 0
+        self.line_gl = []
+        for x, y in zip(x_complete, y_complete):
+            line = self.canvas.axes.plot(
+                x, y, color=self.colors[ind % len(self.colors)],
+                linestyle=self.linestyle[ind // len(self.colors)]
+            )
+            self.line_gl.append(line)
+            ind += 1
+
+    @timer
+    def update(self):
+        if not self._init:
+            self.draw()
+            return
+
+        if self.data is None:
+            return
+
+        self.update_lr()
+        self.update_gl()
+        self.update_current()
+
+        self.update_idle()
+
+    def update_gl(self):
+        self.data.compute_guidelines()
+        x_complete = list(self.data.get_guidelines_x())
+        y_complete = list(self.data.get_guidelines_y())
+
+#        TODO comprendre à quoi sert ce bout de code
+#        ========>
+#        for i in range(self.data.number_profiles):
+#            if i < len(self.line_xy):
+#                self.line_xy[i][0].set_data(
+#                    self.data.profile(i).x(),
+#                    self.data.profile(i).y()
+#                )
+#            else:
+#                self.line_xy.append(
+#                    self.canvas.axes.plot(
+#                        self.data.profile(i).x(),
+#                        self.data.profile(i).y(),
+#                        color='r',
+#                        **self.plot_default_kargs
+#                    )
+#                )
+#        <========
+
+        for i in range(len(x_complete)):
+            if i < len(self.line_gl):
+                self.line_gl[i][0].set_data(
+                    x_complete[i],
+                    y_complete[i]
+                )
+            else:
+                self.line_gl.append(
+                    self.canvas.axes.plot(
+                        x_complete[i],
+                        y_complete[i]
+                    )
+                )
+
+    def update_current(self):
+        if self._current_data_update:
+            self._colors, self._style = self.color_hightlight()
+            self.line_xy_collection.set_colors(self._colors)
+            self.line_xy_collection.set_linestyle(self._style)
+
+    def update_lr(self):
+        for line in self.line_lr:
+            line[0].remove()
+
+        self.draw_lr()

src/View/LateralContribution/Table.py

@@ -86,7 +86,7 @@ class ComboBoxDelegate(QItemDelegate):
                 )
             )
             self.editor.addItems(lst)
-        elif self._mode == "kp":
+        elif self._mode == "rk":
             if self._data is None:
                 self.editor.addItems(
                     ["0"]
@@ -94,7 +94,7 @@ class ComboBoxDelegate(QItemDelegate):
             else:
                 self.editor.addItems(
                     list(
-                        map(str, self._data.reach.get_kp())
+                        map(str, self._data.reach.get_rk())
                     )
                 )
         else:
@@ -154,10 +154,10 @@ class TableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return n.name
-        elif self._headers[column] == "begin_kp":
+        elif self._headers[column] == "begin_rk":
-            return str(self._lst.get(self._tab, row).begin_kp)
+            return str(self._lst.get(self._tab, row).begin_rk)
-        elif self._headers[column] == "end_kp":
+        elif self._headers[column] == "end_rk":
-            return str(self._lst.get(self._tab, row).end_kp)
+            return str(self._lst.get(self._tab, row).end_rk)
 
         return QVariant()
 
@@ -189,13 +189,13 @@ class TableModel(PamhyrTableModel):
                         self._lst, self._tab, row, self._data.edge(value)
                     )
                 )
-            elif self._headers[column] == "begin_kp":
+            elif self._headers[column] == "begin_rk":
                 self._undo.push(
                     SetBeginCommand(
                         self._lst, self._tab, row, value
                     )
                 )
-            elif self._headers[column] == "end_kp":
+            elif self._headers[column] == "end_rk":
                 self._undo.push(
                     SetEndCommand(
                         self._lst, self._tab, row, value

src/View/LateralContribution/UndoCommand.py

@@ -53,14 +53,14 @@ class SetBeginCommand(QUndoCommand):
         self._lcs = lcs
         self._tab = tab
         self._index = index
-        self._old = self._lcs.get(self._tab, self._index).begin_kp
+        self._old = self._lcs.get(self._tab, self._index).begin_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._lcs.get(self._tab, self._index).begin_kp = float(self._old)
+        self._lcs.get(self._tab, self._index).begin_rk = float(self._old)
 
     def redo(self):
-        self._lcs.get(self._tab, self._index).begin_kp = float(self._new)
+        self._lcs.get(self._tab, self._index).begin_rk = float(self._new)
 
 
 class SetEndCommand(QUndoCommand):
@@ -70,14 +70,14 @@ class SetEndCommand(QUndoCommand):
         self._lcs = lcs
         self._tab = tab
         self._index = index
-        self._old = self._lcs.get(self._tab, self._index).end_kp
+        self._old = self._lcs.get(self._tab, self._index).end_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._lcs.get(self._tab, self._index).end_kp = float(self._old)
+        self._lcs.get(self._tab, self._index).end_rk = float(self._old)
 
     def redo(self):
-        self._lcs.get(self._tab, self._index).end_kp = float(self._new)
+        self._lcs.get(self._tab, self._index).end_rk = float(self._new)
 
 
 class SetEdgeCommand(QUndoCommand):

src/View/LateralContribution/Window.py

@@ -54,7 +54,7 @@ from View.LateralContribution.Table import (
 )
 
 from View.Tools.Plot.PamhyrCanvas import MplCanvas
-from View.Geometry.PlotXY import PlotXY
+from View.LateralContribution.PlotXY import PlotXY
 from View.LateralContribution.translate import (
     LC_types, LCTranslate,
 )
@@ -83,12 +83,13 @@ class LateralContributionWindow(PamhyrWindow):
 
         self.setup_table()
         self.setup_graph()
+        self.tabs = self.find(QTabWidget, "tabWidget")
         self.setup_connections()
 
     def setup_table(self):
         self._table = {}
 
-        self._delegate_kp = []
+        self._delegate_rk = []
 
         for t in ["liquid", "solid", "suspenssion"]:
             self._delegate_type = ComboBoxDelegate(
@@ -99,14 +100,14 @@ class LateralContributionWindow(PamhyrWindow):
                 parent=self
             )
 
-            delegate_kp = ComboBoxDelegate(
+            delegate_rk = ComboBoxDelegate(
                 data=None,
-                mode="kp",
+                mode="rk",
                 tab=t,
                 trad=self._trad,
                 parent=self
             )
-            self._delegate_kp.append(delegate_kp)
+            self._delegate_rk.append(delegate_rk)
 
             self._delegate_edge = ComboBoxDelegate(
                 data=self._study.river,
@@ -124,8 +125,8 @@ class LateralContributionWindow(PamhyrWindow):
                 delegates={
                     "type": self._delegate_type,
                     "edge": self._delegate_edge,
-                    "begin_kp": delegate_kp,
+                    "begin_rk": delegate_rk,
-                    "end_kp": delegate_kp,
+                    "end_rk": delegate_rk,
                 },
                 data=self._study.river,
                 undo=self._undo_stack,
@@ -148,6 +149,7 @@ class LateralContributionWindow(PamhyrWindow):
             data=None,
             trad=self._trad,
             toolbar=None,
+            parent=self
         )
 
     def setup_connections(self):
@@ -156,6 +158,8 @@ class LateralContributionWindow(PamhyrWindow):
         self.find(QAction, "action_edit").triggered.connect(self.edit)
         self.find(QAction, "action_sort").triggered.connect(self.sort)
 
+        self.tabs.currentChanged.connect(self._set_current_reach)
+
         for t in ["liquid", "solid", "suspenssion"]:
             table = self.find(QTableView, f"tableView_{t}")
             table.selectionModel()\
@@ -206,9 +210,9 @@ class LateralContributionWindow(PamhyrWindow):
             if edge:
                 data = edge.reach
                 lc = self._lcs.get(tab, rows[0])
-                highlight = (lc.begin_kp, lc.end_kp)
+                highlight = (lc.begin_rk, lc.end_rk)
 
-            for delegate in self._delegate_kp:
+            for delegate in self._delegate_rk:
                 delegate.data = edge
 
         self.plot = PlotXY(
@@ -216,6 +220,7 @@ class LateralContributionWindow(PamhyrWindow):
             data=data,
             trad=self._trad,
             toolbar=None,
+            parent=self
         )
         self.plot.highlight = highlight
         self.plot.update()

src/View/LateralContribution/translate.py

@@ -57,6 +57,6 @@ class LCTranslate(MainTranslate):
             "name": self._dict["name"],
             "type": self._dict["type"],
             "edge": self._dict["reach"],
-            "begin_kp": _translate("LateralContribution", "Start (m)"),
+            "begin_rk": _translate("LateralContribution", "Start (m)"),
-            "end_kp": _translate("LateralContribution", "End (m)")
+            "end_rk": _translate("LateralContribution", "End (m)")
         }

src/View/MainWindow.py

@@ -579,9 +579,13 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             Nothing
         """
         if self._study.filename is None or self._study.filename == "":
+            options = QFileDialog.Options()
+            options |= QFileDialog.DontUseNativeDialog
+
             file_name, _ = QFileDialog.getSaveFileName(
                 self, "Save File",
-                "", "Pamhyr(*.pamhyr)"
+                "", "Pamhyr(*.pamhyr)",
+                options=options,
             )
 
             if file_name.rsplit(".", 1)[-1] == "pamhyr":
@@ -630,9 +634,13 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         Returns:
             Nothing
         """
+        options = QFileDialog.Options()
+        options |= QFileDialog.DontUseNativeDialog
+
         file_name, _ = QFileDialog.getSaveFileName(
             self, "Save File",
-            "", "Pamhyr(*.pamhyr)"
+            "", "Pamhyr(*.pamhyr)",
+            options=options,
         )
 
         logger.debug(f"Save study as : {repr(file_name)}")

src/View/MainWindowTabInfo.py

@@ -191,7 +191,7 @@ class WidgetInfo(PamhyrWidget):
         n_na_hs = 0
 
         for h in hs.lst:
-            if h.input_reach is not None and h.input_kp is not None:
+            if h.input_reach is not None and h.input_rk is not None:
                 n_hs += 1
             else:
                 n_na_hs += 1

src/View/Results/CustomPlot/Plot.py

@@ -71,14 +71,14 @@ class CustomPlot(PamhyrPlot):
 
         self._axes = {}
 
-    def _draw_kp(self):
+    def _draw_rk(self):
         results = self.data
         reach = results.river.reach(self._reach)
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
 
         # self.canvas.axes.set_xlim(
-        #     left=min(kp), right=max(kp)
+        #     left=min(rk), right=max(rk)
         # )
 
         meter_axes = self.canvas.axes
@@ -94,7 +94,7 @@ class CustomPlot(PamhyrPlot):
             # )
 
             line = meter_axes.plot(
-                kp, z_min,
+                rk, z_min,
                 color='grey', lw=1.,
             )
             lines["elevation"] = line
@@ -114,14 +114,14 @@ class CustomPlot(PamhyrPlot):
             # )
 
             line = meter_axes.plot(
-                kp, water_z, lw=1.,
+                rk, water_z, lw=1.,
                 color='blue',
             )
             lines["water_elevation"] = line
 
             if "elevation" in self._y:
                 meter_axes.fill_between(
-                    kp, z_min, water_z,
+                    rk, z_min, water_z,
                     color='blue', alpha=0.5, interpolate=True
                 )
 
@@ -139,7 +139,7 @@ class CustomPlot(PamhyrPlot):
             # )
 
             line = m3s_axes.plot(
-                kp, q, lw=1.,
+                rk, q, lw=1.,
                 color='r',
             )
             lines["discharge"] = line
@@ -312,8 +312,8 @@ class CustomPlot(PamhyrPlot):
             )
             self._axes[axes] = ax_new
 
-        if self._x == "kp":
+        if self._x == "rk":
-            self._draw_kp()
+            self._draw_rk()
         elif self._x == "time":
             self._draw_time()
 
@@ -337,7 +337,7 @@ class CustomPlot(PamhyrPlot):
     def set_profile(self, profile_id):
         self._profile = profile_id
 
-        if self._x != "kp":
+        if self._x != "rk":
             self.update()
 
     def set_timestamp(self, timestamp):

src/View/Results/CustomPlot/Translate.py

@@ -34,7 +34,7 @@ class CustomPlotTranslate(ResultsTranslate):
         # Value type
 
         self._dict['time'] = self._dict["unit_time_s"]
-        self._dict['kp'] = self._dict["unit_kp"]
+        self._dict['rk'] = self._dict["unit_rk"]
         self._dict['water_elevation'] = self._dict["unit_water_elevation"]
         self._dict['discharge'] = self._dict["unit_discharge"]
         self._dict['elevation'] = _translate(
@@ -51,7 +51,7 @@ class CustomPlotTranslate(ResultsTranslate):
         # SubDict
 
         self._sub_dict["values_x"] = {
-            "kp": self._dict["kp"],
+            "rk": self._dict["rk"],
             "time": self._dict["time"],
         }
         self._sub_dict["values_y"] = {

src/View/Results/PlotAC.py

@@ -87,7 +87,7 @@ class PlotAC(PamhyrPlot):
         x = profile.geometry.get_station()
         z = profile.geometry.z()
 
-        self.line_kp, = self.canvas.axes.plot(
+        self.line_rk, = self.canvas.axes.plot(
             x, z,
             linestyle="solid",
             lw=1.5,
@@ -98,7 +98,7 @@ class PlotAC(PamhyrPlot):
     def draw_water_elevation(self, reach, profile):
         x = profile.geometry.get_station()
         z = profile.geometry.z()
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         water_z = profile.get_ts_key(self._current_timestamp, "Z")
 
         self.water, = self.canvas.axes.plot(
@@ -118,7 +118,7 @@ class PlotAC(PamhyrPlot):
     def draw_water_elevation_max(self, reach, profile):
         x = profile.geometry.get_station()
         z = profile.geometry.z()
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         water_z = max(profile.get_key("Z"))
 
         self.water_max, = self.canvas.axes.plot(
@@ -164,7 +164,7 @@ class PlotAC(PamhyrPlot):
         self.update_idle()
 
     def update_river_bottom(self, reach, profile, x, z):
-        self.line_kp.set_data(x, z)
+        self.line_rk.set_data(x, z)
 
     def update_water(self, reach, profile, x, z):
         water_z = profile.get_ts_key(self._current_timestamp, "Z")

src/View/Results/PlotRKC.py

@@ -1,4 +1,4 @@
-# PlotKPC.py -- Pamhyr
+# PlotRKC.py -- Pamhyr
 # Copyright (C) 2023-2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,11 +30,11 @@ from PyQt5.QtCore import (
 logger = logging.getLogger()
 
 
-class PlotKPC(PamhyrPlot):
+class PlotRKC(PamhyrPlot):
     def __init__(self, canvas=None, trad=None, toolbar=None,
                  results=None, reach_id=0, profile_id=0,
                  parent=None):
-        super(PlotKPC, self).__init__(
+        super(PlotRKC, self).__init__(
             canvas=canvas,
             trad=trad,
             data=results,
@@ -47,7 +47,7 @@ class PlotKPC(PamhyrPlot):
         self._current_reach_id = reach_id
         self._current_profile_id = profile_id
 
-        self.label_x = self._trad["unit_kp"]
+        self.label_x = self._trad["unit_rk"]
         self.label_y = self._trad["unit_elevation"]
 
         self.label_bottom = self._trad["label_bottom"]
@@ -95,11 +95,11 @@ class PlotKPC(PamhyrPlot):
     def draw_bottom_with_bedload(self, reach):
         self._bedrock = self.sl_compute_bedrock(reach)
 
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z = self.sl_compute_current_z(reach)
 
         self.line_bottom, = self.canvas.axes.plot(
-            kp, z,
+            rk, z,
             linestyle="solid", lw=1.,
             color=self.color_plot_river_bottom,
         )
@@ -116,7 +116,7 @@ class PlotKPC(PamhyrPlot):
         )
 
         for hs in lhs:
-            x = hs.input_kp
+            x = hs.input_rk
             z_min = reach.geometry.get_z_min()
             z_max = reach.geometry.get_z_max()
 
@@ -190,12 +190,12 @@ class PlotKPC(PamhyrPlot):
         )
 
     def draw_bottom_geometry(self, reach):
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
 
-        self.line_kp_zmin = self.canvas.axes.plot(
+        self.line_rk_zmin = self.canvas.axes.plot(
-            kp, z_min,
+            rk, z_min,
             color=self.color_plot_river_bottom,
             lw=1.
         )
@@ -204,7 +204,7 @@ class PlotKPC(PamhyrPlot):
 
     def draw_water_elevation(self, reach):
         if len(reach.geometry.profiles) != 0:
-            kp = reach.geometry.get_kp()
+            rk = reach.geometry.get_rk()
             z_min = reach.geometry.get_z_min()
 
             water_z = list(
@@ -217,12 +217,12 @@ class PlotKPC(PamhyrPlot):
             )
 
             self.water = self.canvas.axes.plot(
-                kp, water_z,
+                rk, water_z,
                 lw=1., color=self.color_plot_river_water,
             )
 
             self.water_fill = self.canvas.axes.fill_between(
-                kp, self._river_bottom, water_z,
+                rk, self._river_bottom, water_z,
                 color=self.color_plot_river_water_zone,
                 alpha=0.7,
                 interpolate=True
@@ -230,7 +230,7 @@ class PlotKPC(PamhyrPlot):
 
     def draw_water_elevation_max(self, reach):
         if len(reach.geometry.profiles) != 0:
-            kp = reach.geometry.get_kp()
+            rk = reach.geometry.get_rk()
             z_min = reach.geometry.get_z_min()
 
             water_z = list(
@@ -241,20 +241,20 @@ class PlotKPC(PamhyrPlot):
             )
 
             self.canvas.axes.plot(
-                kp, water_z, lw=1.,
+                rk, water_z, lw=1.,
                 color=self.color_plot_river_water,
                 linestyle='dotted',
             )
 
     def draw_current(self, reach):
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
 
         self.profile, = self.canvas.axes.plot(
             [
-                kp[self._current_profile_id],
+                rk[self._current_profile_id],
-                kp[self._current_profile_id]
+                rk[self._current_profile_id]
             ],
             [
                 z_max[self._current_profile_id],
@@ -285,7 +285,7 @@ class PlotKPC(PamhyrPlot):
 
         for profile, z in overflow:
             self.canvas.axes.plot(
-                profile.kp, z,
+                profile.rk, z,
                 lw=1.,
                 color=self.color_plot,
                 markersize=3,
@@ -330,7 +330,7 @@ class PlotKPC(PamhyrPlot):
 
     def update_water_elevation(self):
         reach = self.results.river.reach(self._current_reach_id)
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
 
         water_z = list(
@@ -343,38 +343,38 @@ class PlotKPC(PamhyrPlot):
         )
 
         self.water[0].set_data(
-            kp, water_z
+            rk, water_z
         )
 
         self.water_fill.remove()
         self.water_fill = self.canvas.axes.fill_between(
-            kp, self._river_bottom, water_z,
+            rk, self._river_bottom, water_z,
             color=self.color_plot_river_water_zone,
             alpha=0.7, interpolate=True
         )
 
     def update_current(self):
         reach = self.results.river.reach(self._current_reach_id)
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
         cid = self._current_profile_id
 
         self.profile.set_data(
-            [kp[cid], kp[cid]],
+            [rk[cid], rk[cid]],
             [z_max[cid], z_min[cid]]
         )
         self.canvas.figure.canvas.draw_idle()
 
     def update_bottom_with_bedload(self):
         reach = self.results.river.reach(self._current_reach_id)
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z = self.sl_compute_current_z(reach)
 
         self.line_bottom.remove()
 
         self.line_bottom, = self.canvas.axes.plot(
-            kp, z,
+            rk, z,
             linestyle="solid", lw=1.,
             color=self.color_plot_river_bottom,
         )

src/View/Results/PlotSedProfile.py

@@ -164,10 +164,10 @@ class PlotSedProfile(PamhyrPlot):
 
         z_sl = self.get_zsl(profile)
 
-        self.line_kp_sl = []
+        self.line_rk_sl = []
         for i, zsl in enumerate(z_sl):
-            self.line_kp_sl.append(None)
+            self.line_rk_sl.append(None)
-            self.line_kp_sl[i], = self.canvas.axes.plot(
+            self.line_rk_sl[i], = self.canvas.axes.plot(
                 x, zsl,
                 linestyle="solid" if i == len(z_sl) - 1 else "--",
                 lw=1.8,

src/View/Results/PlotSedReach.py

@@ -62,7 +62,7 @@ class PlotSedReach(PamhyrPlot):
 
     # DEPRECATED version of sediment layser display
     # def _get_zsl(self, reach):
-    #     kp = reach.geometry.get_kp()
+    #     rk = reach.geometry.get_rk()
     #     z_min = reach.geometry.get_z_min()
     #     z_max = reach.geometry.get_z_max()
 
@@ -91,7 +91,7 @@ class PlotSedReach(PamhyrPlot):
     #         sl.append(cur)
 
     #     self.canvas.axes.set_xlim(
-    #         left = min(kp) - 10, right = max(kp) + 10
+    #         left = min(rk) - 10, right = max(rk) + 10
     #     )
 
     #     # Dummy layer with height = 0
@@ -133,7 +133,7 @@ class PlotSedReach(PamhyrPlot):
     #     return z_sl
 
     def get_zsl(self, reach):
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
 
@@ -239,18 +239,18 @@ class PlotSedReach(PamhyrPlot):
             color='black', fontsize=10
         )
 
-        kp = reach.geometry.get_kp()
+        rk = reach.geometry.get_rk()
         z_min = reach.geometry.get_z_min()
         z_max = reach.geometry.get_z_max()
 
         z_sl = self.get_zsl(reach)
 
         # Draw
-        self.line_kp_sl = []
+        self.line_rk_sl = []
         for i, z in enumerate(z_sl):
-            self.line_kp_sl.append(None)
+            self.line_rk_sl.append(None)
-            self.line_kp_sl[i], = self.canvas.axes.plot(
+            self.line_rk_sl[i], = self.canvas.axes.plot(
-                kp, z,
+                rk, z,
                 linestyle="solid" if i == len(z_sl) - 1 else "--",
                 lw=1.8,
                 color='grey' if i == len(z_sl) - 1 else None

src/View/Results/PlotXY.py

@@ -22,10 +22,14 @@ from functools import reduce
 
 from tools import timer, trace
 from View.Tools.PamhyrPlot import PamhyrPlot
+import numpy as np
+from matplotlib import collections
 
 from PyQt5.QtCore import (
-    QCoreApplication
+    QCoreApplication, Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange
 )
+from PyQt5.QtWidgets import QApplication, QTableView
 
 _translate = QCoreApplication.translate
 
@@ -57,6 +61,74 @@ class PlotXY(PamhyrPlot):
         self.label_y = _translate("Results", "Y (m)")
 
         self._isometric_axis = True
+        self._tablemodel = parent._table["profile"]
+        self._table = parent.find(QTableView, f"tableView_profile")
+
+    def onpick(self, event):
+        print(event.mouseevent.button.value)
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        ind, point = self._closest_section(event)
+        if self._table is None:
+            return
+        self._select_in_table([ind])
+        self._table.blockSignals(False)
+
+        return
+
+    def _closest_section(self, event):
+        axes = self.canvas.axes
+        mx = event.mouseevent.xdata
+        my = event.mouseevent.ydata
+        bx, by = axes.get_xlim(), axes.get_ylim()
+        ratio = (bx[0] - bx[1]) / (by[0] - by[1])
+
+        segments = event.artist.get_segments()
+        ind = event.ind
+
+        points = []
+        for i in ind:
+            points = points + [[i, j] for j in segments[i]]
+
+        def dist_mouse(point):
+            x, y = point[1]
+            d2 = (((mx - x) / ratio) ** 2) + ((my - y) ** 2)
+            return d2
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _select_in_table(self, ind):
+        if self._table is None:
+            return
+        self._table.setFocus()
+        selection = self._table.selectionModel()
+        index = QItemSelection()
+        if len(ind) == 0:
+            return
+        for i in ind:
+            index.append(QItemSelectionRange(self._table.model().index(i, 0)))
+        selection.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+
+        if len(ind) > 0:
+            self._table.scrollTo(self._table.model().index(ind[-1], 0))
 
     @property
     def results(self):
@@ -90,18 +162,36 @@ class PlotXY(PamhyrPlot):
             self._init = False
             return
 
-        self.line_xy = [
+        self.line_xy = []
-            self.canvas.axes.plot(
+        for xy in zip(reach.geometry.get_x(),
-                x, y,
+                      reach.geometry.get_y()):
-                color=self.color_plot_river_bottom,
+            self.line_xy.append(np.column_stack(xy))
-                **self.plot_default_kargs
+
-            )
+        self._colors, self._style = self.color_hightlight()
-            for x, y, kp in zip(
+        self.line_xy_collection = collections.LineCollection(
-                reach.geometry.get_x(),
+            self.line_xy,
-                reach.geometry.get_y(),
+            colors=self._colors,
-                reach.geometry.get_kp()
+            linestyle=self._style,
-            )
+            picker=10
-        ]
+        )
+        self.canvas.axes.add_collection(self.line_xy_collection)
+
+    def color_hightlight(self):
+        reach = self.results.river.reach(self._current_reach_id)
+        rows = [self._current_profile_id]
+        colors = [self.color_plot
+                  for row in range(reach.geometry.number_profiles)]
+        style = ["-" for row in range(reach.geometry.number_profiles)]
+        if len(rows) > 0:
+            for row in rows:
+                colors[row] = self.color_plot_current
+            if rows[0] > 0:
+                colors[rows[0]-1] = self.color_plot_previous
+                style[rows[0]-1] = "--"
+            if rows[-1] < reach.geometry.number_profiles-1:
+                colors[rows[-1]+1] = self.color_plot_next
+                style[rows[-1]+1] = "--"
+        return colors, style
 
     def draw_guide_lines(self, reach):
         x_complete = reach.geometry.get_guidelines_x()

src/View/Results/Table.py

@@ -71,14 +71,14 @@ class TableModel(PamhyrTableModel):
             if self._headers[column] == "name":
                 v = self._lst[row].name
                 return str(v)
-            elif self._headers[column] == "kp":
+            elif self._headers[column] == "rk":
-                v = self._lst[row].kp
+                v = self._lst[row].rk
                 return f"{v:.4f}"
         elif self._opt_data == "raw_data":
             p = self._lst[row]
             if self._headers[column] == "name":
                 if p.name == "":
-                    return f"{p.kp:.4f}"
+                    return f"{p.rk:.4f}"
                 return f"{p.name}"
             elif self._headers[column] == "water_elevation":
                 v = self._lst[row].get_ts_key(self._timestamp, "Z")

src/View/Results/Window.py

@@ -48,7 +48,7 @@ from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 
 from View.Results.PlotXY import PlotXY
 from View.Results.PlotAC import PlotAC
-from View.Results.PlotKPC import PlotKPC
+from View.Results.PlotRKC import PlotRKC
 from View.Results.PlotH import PlotH
 from View.Results.PlotSedReach import PlotSedReach
 from View.Results.PlotSedProfile import PlotSedProfile
@@ -176,7 +176,8 @@ class ResultsWindow(PamhyrWindow):
             profile_id=0,
             trad=self._trad,
             toolbar=self.toolbar,
-            display_current=True
+            display_current=True,
+            parent=self
         )
         self.plot_xy.draw()
 
@@ -192,7 +193,7 @@ class ResultsWindow(PamhyrWindow):
         self.plot_layout_2.addWidget(self.toolbar_2)
         self.plot_layout_2.addWidget(self.canvas_2)
 
-        self.plot_kpc = PlotKPC(
+        self.plot_rkc = PlotRKC(
             canvas=self.canvas_2,
             results=self._results,
             reach_id=0,
@@ -200,7 +201,7 @@ class ResultsWindow(PamhyrWindow):
             trad=self._trad,
             toolbar=self.toolbar_2
         )
-        self.plot_kpc.draw()
+        self.plot_rkc.draw()
 
         self.canvas_3 = MplCanvas(width=5, height=4, dpi=100)
         self.canvas_3.setObjectName("canvas_3")
@@ -282,7 +283,7 @@ class ResultsWindow(PamhyrWindow):
         else:
             profile = reach.reach.profile(indexes[0].row())
 
-        pname = profile.name if profile.name != "" else profile.kp
+        pname = profile.name if profile.name != "" else profile.rk
 
         return (f"Reach: {reach.name} | " +
                 f"Profile: {pname} | " +
@@ -371,7 +372,7 @@ class ResultsWindow(PamhyrWindow):
         if reach_id is not None:
             self.plot_xy.set_reach(reach_id)
             self.plot_ac.set_reach(reach_id)
-            self.plot_kpc.set_reach(reach_id)
+            self.plot_rkc.set_reach(reach_id)
             self.plot_h.set_reach(reach_id)
 
             for plot in self._additional_plot:
@@ -383,7 +384,7 @@ class ResultsWindow(PamhyrWindow):
         if profile_id is not None:
             self.plot_xy.set_profile(profile_id)
             self.plot_ac.set_profile(profile_id)
-            self.plot_kpc.set_profile(profile_id)
+            self.plot_rkc.set_profile(profile_id)
             self.plot_h.set_profile(profile_id)
 
             for plot in self._additional_plot:
@@ -394,7 +395,7 @@ class ResultsWindow(PamhyrWindow):
         if timestamp is not None:
             self.plot_xy.set_timestamp(timestamp)
             self.plot_ac.set_timestamp(timestamp)
-            self.plot_kpc.set_timestamp(timestamp)
+            self.plot_rkc.set_timestamp(timestamp)
             self.plot_h.set_timestamp(timestamp)
 
             for plot in self._additional_plot:
@@ -464,12 +465,12 @@ class ResultsWindow(PamhyrWindow):
     def _reload_plots(self):
         self.plot_xy.results = self._results
         self.plot_ac.results = self._results
-        self.plot_kpc.results = self._results
+        self.plot_rkc.results = self._results
         self.plot_h.results = self._results
 
         self.plot_xy.draw()
         self.plot_ac.draw()
-        self.plot_kpc.draw()
+        self.plot_rkc.draw()
         self.plot_h.draw()
 
     def _reload_slider(self):
@@ -605,7 +606,7 @@ class ResultsWindow(PamhyrWindow):
         with open(file_name, 'w', newline='') as csvfile:
             writer = csv.writer(csvfile, delimiter=',',
                                 quotechar='|', quoting=csv.QUOTE_MINIMAL)
-            writer.writerow(["name", "kp", "data-file"])
+            writer.writerow(["name", "rk", "data-file"])
             for profile in reach.profiles:
                 p_file_name = os.path.join(
                     directory,
@@ -614,7 +615,7 @@ class ResultsWindow(PamhyrWindow):
 
                 writer.writerow([
                     profile.name,
-                    profile.kp,
+                    profile.rk,
                     p_file_name
                 ])
 

src/View/Results/translate.py

@@ -50,7 +50,7 @@ class ResultsTranslate(MainTranslate):
 
         self._sub_dict["table_headers_profile"] = {
             "name": self._dict["name"],
-            "kp": self._dict["unit_kp"],
+            "rk": self._dict["unit_rk"],
         }
 
         self._sub_dict["table_headers_raw_data"] = {

src/View/SedimentLayers/Edit/Plot.py

@@ -42,8 +42,8 @@ class Plot(PamhyrPlot):
 
         self.label_y = self._trad["height"]
 
-        self.line_kp_zmin = None
+        self.line_rk_zmin = None
-        self.line_kp_sl = []
+        self.line_rk_sl = []
 
         self._isometric_axis = False
 
@@ -73,8 +73,8 @@ class Plot(PamhyrPlot):
         self.canvas.axes.set_xlim(*x)
 
         for i, zsl in enumerate(reversed(z_sl)):
-            self.line_kp_sl.append(None)
+            self.line_rk_sl.append(None)
-            self.line_kp_sl[i], = self.canvas.axes.plot(
+            self.line_rk_sl[i], = self.canvas.axes.plot(
                 x, zsl,
                 label=names[-(i+1)],
                 linestyle="solid" if i == len(names) - 1 else "--",

src/View/SedimentLayers/Reach/Plot.py

@@ -43,11 +43,11 @@ class Plot(PamhyrPlot):
             parent=parent
         )
 
-        self.label_x = self._trad["kp"]
+        self.label_x = self._trad["rk"]
         self.label_y = self._trad["height"]
 
-        self.line_kp_zmin = None
+        self.line_rk_zmin = None
-        self.line_kp_sl = []
+        self.line_rk_sl = []
 
         self._isometric_axis = False
 
@@ -71,12 +71,12 @@ class Plot(PamhyrPlot):
         self._init = True
 
     def draw_data(self):
-        kp = self.data.get_kp()
+        rk = self.data.get_rk()
         sl = self.data.get_sl()
         z_min = self.data.get_z_min()
 
         self.canvas.axes.set_xlim(
-            left=min(kp), right=max(kp)
+            left=min(rk), right=max(rk)
         )
 
         z_sl = reduce(
@@ -93,9 +93,9 @@ class Plot(PamhyrPlot):
         )
 
         for i, z in enumerate(reversed(z_sl)):
-            self.line_kp_sl.append(None)
+            self.line_rk_sl.append(None)
-            self.line_kp_sl[i], = self.canvas.axes.plot(
+            self.line_rk_sl[i], = self.canvas.axes.plot(
-                kp, z,
+                rk, z,
                 linestyle="solid" if i == len(z_sl) - 1 else "--",
                 lw=1.5,
                 color='grey' if i == len(z_sl) - 1 else None

src/View/SedimentLayers/Reach/Profile/Plot.py

@@ -46,8 +46,8 @@ class Plot(PamhyrPlot):
         self.label_x = self._trad["x"]
         self.label_y = self._trad["height"]
 
-        self.line_kp_zmin = None
+        self.line_rk_zmin = None
-        self.line_kp_sl = []
+        self.line_rk_sl = []
 
         self._isometric_axis = False
 
@@ -86,8 +86,8 @@ class Plot(PamhyrPlot):
         )
 
         for i, zsl in enumerate(reversed(z_sl)):
-            self.line_kp_sl.append(None)
+            self.line_rk_sl.append(None)
-            self.line_kp_sl[i], = self.canvas.axes.plot(
+            self.line_rk_sl[i], = self.canvas.axes.plot(
                 x, zsl,
                 linestyle="solid" if i == len(z_sl) - 1 else "--",
                 lw=1.8,

src/View/SedimentLayers/Reach/Profile/Window.py

@@ -91,7 +91,7 @@ class ProfileSedimentLayersWindow(PamhyrWindow):
         if pname == "":
             pname = _translate(
                 "SedimentLayers",
-                "(no name - @kp)").replace("@kp", str(self._profile.kp)
+                "(no name - @rk)").replace("@rk", str(self._profile.rk)
                                            )
 
         return (

src/View/SedimentLayers/Reach/Table.py

@@ -101,8 +101,8 @@ class TableModel(PamhyrTableModel):
 
         if self._headers[column] == "name":
             return self._data.profile(row).name
-        if self._headers[column] == "kp":
+        if self._headers[column] == "rk":
-            return self._data.profile(row).kp
+            return self._data.profile(row).rk
         if self._headers[column] == "sl":
             value = self._data.profile(row).sl
             if value is None:

src/View/SedimentLayers/Reach/translate.py

@@ -34,11 +34,11 @@ class SedimentReachTranslate(SedimentTranslate):
             "SedimentLayers", "Apply sediment layers to reach"
         )
 
-        self._dict["kp"] = self._dict["unit_kp"]
+        self._dict["rk"] = self._dict["unit_rk"]
         self._dict["height"] = self._dict["unit_height"]
 
         self._sub_dict["table_headers"] = {
             "name": self._dict["name"],
-            "kp": self._dict["unit_kp"],
+            "rk": self._dict["unit_rk"],
             "sl": _translate("SedimentLayers", "Sediment layers"),
         }

src/View/Tools/ASubWindow.py

@@ -35,7 +35,7 @@ from PyQt5.QtWidgets import (
     QRadioButton, QComboBox, QFileDialog,
     QMessageBox, QTableView, QAction,
     QDateTimeEdit, QWidget, QPlainTextEdit,
-    QLabel, QDoubleSpinBox,
+    QLabel, QDoubleSpinBox, QButtonGroup,
 )
 from PyQt5.QtCore import (
     QTime, QDateTime,
@@ -501,6 +501,17 @@ class ASubWindowFeatures(object):
         qdate = QDateTime.fromString(date.isoformat(), "yyyy-MM-ddThh:mm:ss")
         self.find(QDateTimeEdit, name).setDateTime(qdate)
 
+    def get_checked_id_button_group(self, name: str):
+        """Get current checked button id in a buttonGroup
+
+        Args:
+            name: The buttonGroup component name
+
+        Returns:
+            Current checked id
+        """
+        return self.find(QButtonGroup, name).checkedId()
+
 
 # Top level interface
 

src/View/Tools/PamhyrPlot.py

@@ -16,6 +16,8 @@
 
 # -*- coding: utf-8 -*-
 
+import logging
+
 import matplotlib.colors as mplcolors
 from matplotlib import ticker
 
@@ -25,6 +27,8 @@ from View.Tools.Plot.APlot import APlot
 from View.Tools.Plot.PamhyrCanvas import MplCanvas
 from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 
+logger = logging.getLogger()
+
 
 class PamhyrPlot(APlot):
     color_axes = "black"
@@ -38,7 +42,6 @@ class PamhyrPlot(APlot):
     color_plot_river_bottom = "grey"
     color_plot_river_water = "blue"
     color_plot_river_water_zone = "skyblue"
-
     colors = list(mplcolors.TABLEAU_COLORS)
     linestyle = ['solid', 'dashed', 'dashdot', 'dotted']
 
@@ -77,6 +80,7 @@ class PamhyrPlot(APlot):
         connector = {
             'pick_event': self.onpick,
             'button_press_event': self.onclick,
+            'button_release_event': self.onrelease,
         }
 
         for event in connector:
@@ -100,6 +104,7 @@ class PamhyrPlot(APlot):
         self._highlight_data_update = False
         self._current_data = None  #: Current data identifier
         self._current_data_update = False
+        self._rect_select = None
 
     @property
     def canvas(self):
@@ -231,3 +236,13 @@ class PamhyrPlot(APlot):
 
     def onclick(self, event):
         return
+
+    def onrelease(self, event):
+        return
+
+    def rect_select_callback(self, eclick, erelease):
+        'eclick and erelease are the press and release events'
+        x1, y1 = eclick.xdata, eclick.ydata
+        x2, y2 = erelease.xdata, erelease.ydata
+        logging.debug("(%3.2f, %3.2f) --> (%3.2f, %3.2f)" % (x1, y1, x2, y2))
+        return

src/View/Translate.py

@@ -52,7 +52,8 @@ class UnitTranslate(CommonWordTranslate):
     def __init__(self):
         super(UnitTranslate, self).__init__()
 
-        self._dict["unit_kp"] = _translate("Unit", "Position (m)")
+        self._dict["unit_rk"] = _translate("Unit", "River Kilometric (m)")
+        self._dict["unit_rk_short"] = _translate("Unit", "RK (m)")
         self._dict["unit_width"] = _translate("Unit", "Width (m)")
         self._dict["unit_height"] = _translate("Unit", "Height (m)")
         self._dict["unit_diameter"] = _translate("Unit", "Diameter (m)")

src/View/ui/GeometryReach.ui

@@ -28,49 +28,6 @@
         <item>
          <widget class="QTableView" name="tableView"/>
         </item>
-        <item>
-         <layout class="QVBoxLayout" name="verticalLayout_5">
-          <item>
-           <widget class="QPushButton" name="pushButton_up">
-            <property name="text">
-             <string/>
-            </property>
-            <property name="icon">
-             <iconset>
-              <normaloff>ressources/up.png</normaloff>ressources/up.png</iconset>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_2">
-            <item>
-             <widget class="QSlider" name="verticalSlider">
-              <property name="orientation">
-               <enum>Qt::Vertical</enum>
-              </property>
-              <property name="invertedAppearance">
-               <bool>true</bool>
-              </property>
-              <property name="invertedControls">
-               <bool>true</bool>
-              </property>
-             </widget>
-            </item>
-           </layout>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pushButton_down">
-            <property name="text">
-             <string/>
-            </property>
-            <property name="icon">
-             <iconset>
-              <normaloff>ressources/down.png</normaloff>ressources/down.png</iconset>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
        </layout>
       </widget>
       <widget class="QSplitter" name="splitter_2">
@@ -133,7 +90,7 @@
    <addaction name="action_down"/>
    <addaction name="action_export"/>
    <addaction name="action_meshing"/>
-   <addaction name="action_update_kp"/>
+   <addaction name="action_update_rk"/>
    <addaction name="action_purge"/>
   </widget>
   <action name="action_import">
@@ -253,12 +210,12 @@
     <string>Meshing</string>
    </property>
   </action>
-  <action name="action_update_kp">
+  <action name="action_update_rk">
    <property name="text">
-    <string>Update KP</string>
+    <string>Update RK</string>
    </property>
    <property name="toolTip">
-    <string>Recompute KP</string>
+    <string>Recompute RK</string>
    </property>
   </action>
   <action name="action_purge">

src/View/ui/MeshingOptions.ui

@@ -170,7 +170,7 @@
          </widget>
         </item>
         <item>
-         <widget class="QComboBox" name="comboBox_begin_kp">
+         <widget class="QComboBox" name="comboBox_begin_rk">
           <property name="enabled">
            <bool>true</bool>
           </property>
@@ -191,7 +191,7 @@
          </widget>
         </item>
         <item>
-         <widget class="QComboBox" name="comboBox_end_kp">
+         <widget class="QComboBox" name="comboBox_end_rk">
           <property name="enabled">
            <bool>true</bool>
           </property>

src/View/ui/UpdateKPOptions.ui

@@ -6,37 +6,23 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>340</width>
+    <width>381</width>
-    <height>204</height>
+    <height>302</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Dialog</string>
   </property>
+  <property name="layoutDirection">
+   <enum>Qt::LeftToRight</enum>
+  </property>
   <layout class="QGridLayout" name="gridLayout_4">
-   <item row="1" column="0">
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
-     </property>
-    </widget>
-   </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
       <string>Distance computation</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
-      <item row="3" column="1">
-       <widget class="QComboBox" name="comboBox_end_gl">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
       <item row="3" column="0">
        <widget class="QLabel" name="label_6">
         <property name="enabled">
@@ -47,11 +33,17 @@
         </property>
        </widget>
       </item>
-      <item row="2" column="1">
+      <item row="5" column="1">
-       <widget class="QComboBox" name="comboBox_begin_gl">
+       <widget class="QRadioButton" name="radioButton_1">
-        <property name="enabled">
+        <property name="text">
-         <bool>true</bool>
+         <string>Upstream to downstream</string>
         </property>
+        <property name="checked">
+         <bool>false</bool>
+        </property>
+        <attribute name="buttonGroup">
+         <string notr="true">buttonGroup_orientation</string>
+        </attribute>
        </widget>
       </item>
       <item row="2" column="0">
@@ -67,20 +59,6 @@
       <item row="0" column="1">
        <widget class="QComboBox" name="comboBox_origin"/>
       </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_3">
-        <property name="text">
-         <string>Origin</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="label_4">
-        <property name="text">
-         <string>Origin value</string>
-        </property>
-       </widget>
-      </item>
       <item row="1" column="1">
        <widget class="QDoubleSpinBox" name="doubleSpinBox_origin">
         <property name="decimals">
@@ -94,9 +72,80 @@
         </property>
        </widget>
       </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Origin</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QComboBox" name="comboBox_begin_gl">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_4">
+        <property name="text">
+         <string>Origin value</string>
+        </property>
+       </widget>
+      </item>
+      <item row="9" column="1">
+       <widget class="QRadioButton" name="radioButton_2">
+        <property name="text">
+         <string>Downstream to upstream</string>
+        </property>
+        <attribute name="buttonGroup">
+         <string notr="true">buttonGroup_orientation</string>
+        </attribute>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QComboBox" name="comboBox_end_gl">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="label_7">
+        <property name="text">
+         <string>Orientation</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QRadioButton" name="radioButton_0">
+        <property name="layoutDirection">
+         <enum>Qt::LeftToRight</enum>
+        </property>
+        <property name="text">
+         <string>Keep current</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+        <attribute name="buttonGroup">
+         <string notr="true">buttonGroup_orientation</string>
+        </attribute>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
+   <item row="1" column="0">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>
@@ -134,4 +183,7 @@
    </hints>
   </connection>
  </connections>
+ <buttongroups>
+  <buttongroup name="buttonGroup_orientation"/>
+ </buttongroups>
 </ui>

src/lang/fr.ts

@@ -754,27 +754,27 @@
         <translation>Stricklers</translation>
     </message>
     <message>
-        <location filename="../View/ui/UpdateKPOptions.ui" line="30"/>
+        <location filename="../View/ui/UpdateRKOptions.ui" line="30"/>
         <source>Distance computation</source>
         <translation>Calcule des distances</translation>
     </message>
     <message>
-        <location filename="../View/ui/UpdateKPOptions.ui" line="46"/>
+        <location filename="../View/ui/UpdateRKOptions.ui" line="46"/>
         <source>Second guide-line</source>
         <translation>Deuxième ligne directrice</translation>
     </message>
     <message>
-        <location filename="../View/ui/UpdateKPOptions.ui" line="63"/>
+        <location filename="../View/ui/UpdateRKOptions.ui" line="63"/>
         <source>First guide-line</source>
         <translation>Première ligne directrice</translation>
     </message>
     <message>
-        <location filename="../View/ui/UpdateKPOptions.ui" line="73"/>
+        <location filename="../View/ui/UpdateRKOptions.ui" line="73"/>
         <source>Origin</source>
         <translation>Origine</translation>
     </message>
     <message>
-        <location filename="../View/ui/UpdateKPOptions.ui" line="80"/>
+        <location filename="../View/ui/UpdateRKOptions.ui" line="80"/>
         <source>Origin value</source>
         <translation>Valeur de l&apos;origine</translation>
     </message>
@@ -2423,12 +2423,12 @@
     </message>
     <message>
         <location filename="../View/ui/GeometryReach.ui" line="258"/>
-        <source>Update KP</source>
+        <source>Update RK</source>
         <translation>Mise à jour des PK</translation>
     </message>
     <message>
         <location filename="../View/ui/GeometryReach.ui" line="261"/>
-        <source>Recompute KP</source>
+        <source>Recompute RK</source>
         <translation>Recalcule des PK</translation>
     </message>
     <message>
@@ -2684,8 +2684,8 @@
     </message>
     <message>
         <location filename="../View/SedimentLayers/Reach/Profile/Window.py" line="92"/>
-        <source>(no name - @kp)</source>
+        <source>(no name - @rk)</source>
-        <translation>(sans nom - @kp)</translation>
+        <translation>(sans nom - @rk)</translation>
     </message>
     <message>
         <location filename="../View/SedimentLayers/Reach/Profile/translate.py" line="40"/>