boris-behav-obs 9.2.3__py2.py3-none-any.whl → 9.3__py2.py3-none-any.whl

boris/{map_creator.py → modifier_coding_map_creator.py}

@@ -20,9 +20,14 @@ This file is part of BORIS.
 
 """
 
+# to run this file, use
+# python -m boris.modifier_coding_map_creator
+
 import binascii
+import io
 import json
 import os
+import re
 
 from PySide6.QtCore import (
     Qt,
@@ -34,7 +39,6 @@ from PySide6.QtCore import (
     QLineF,
 )
 from PySide6.QtGui import QColor, QBrush, QMouseEvent, QPixmap, QIcon, QPen, QPolygon, QPolygonF, QAction
-
 from PySide6.QtWidgets import (
     QGraphicsPolygonItem,
     QGraphicsEllipseItem,
@@ -55,6 +59,11 @@ from PySide6.QtWidgets import (
     QInputDialog,
     QFileDialog,
     QApplication,
+    QListWidget,
+    QSplitter,
+    QSpacerItem,
+    QSizePolicy,
+    QFrame,
 )
 
 from . import config as cfg
@@ -62,7 +71,7 @@ from . import dialog
 from . import utilities as util
 
 designColor = QColor(255, 0, 0, 128)  # red opacity: 50%
-penWidth = 0
+penWidth: int = 0
 penStyle = Qt.NoPen
 selectedBrush = QBrush()
 selectedBrush.setStyle(Qt.SolidPattern)
@@ -82,8 +91,9 @@ class ModifiersMapCreatorWindow(QMainWindow):
         def mousePressEvent(self, event):
             self.mousePress.emit(event)
 
-        _start = 0
-        elList, points = [], []
+        _start: int = 0
+        elList: list = []
+        points: list = []
 
         def __init__(self, parent):
             QGraphicsView.__init__(self, parent)
@@ -91,9 +101,13 @@ class ModifiersMapCreatorWindow(QMainWindow):
             self.setScene(QGraphicsScene(self))
             self.scene().update()
 
-    bitmapFileName, mapName, fileName = "", "", ""
-    flagNewArea, flagMapChanged = False, False
-    areasList, polygonsList2 = {}, {}
+    bitmapFileName: str = ""
+    mapName: str = ""
+    fileName: str = ""
+    flagNewArea: bool = False
+    flag_map_changed: bool = False
+    areasList: dict = {}
+    polygonsList2: dict = {}
     areaColor = QColor("lime")
 
     def __init__(self):
@@ -147,91 +161,153 @@ class ModifiersMapCreatorWindow(QMainWindow):
         fileMenu.addSeparator()
         fileMenu.addAction(self.exitAction)
 
+        splitter1 = QSplitter(Qt.Vertical)
+
         self.view = self.View(self)
         self.view.mousePress.connect(self.viewMousePressEvent)
+        splitter1.addWidget(self.view)
 
-        self.btLoad = QPushButton("Load bitmap", self)
-        self.btLoad.clicked.connect(self.loadBitmap)
-        self.btLoad.setVisible(False)
+        vlayout_list = QVBoxLayout()
+        vlayout_list.addWidget(QLabel("List of modifiers"))
+
+        self.area_list = QListWidget(self)
+        self.area_list.itemClicked.connect(self.area_list_item_click)
+        vlayout_list.addWidget(self.area_list)
+        w = QWidget()
+        w.setLayout(vlayout_list)
+        splitter1.addWidget(w)
+        splitter1.setSizes([300, 100])
+        splitter1.setStretchFactor(2, 8)
+
+        hlayout_cmd = QHBoxLayout()
 
         self.btNewArea = QPushButton("New modifier", self)
         self.btNewArea.clicked.connect(self.newArea)
         self.btNewArea.setVisible(False)
+        hlayout_cmd.addWidget(self.btNewArea)
+
+        self.btSaveArea = QPushButton("Save modifier", self)
+        self.btSaveArea.clicked.connect(self.saveArea)
+        self.btSaveArea.setVisible(False)
+        hlayout_cmd.addWidget(self.btSaveArea)
 
-        self.hlayout = QHBoxLayout()
+        self.btCancelAreaCreation = QPushButton("Cancel new modifier", self)
+        self.btCancelAreaCreation.clicked.connect(self.cancelAreaCreation)
+        self.btCancelAreaCreation.setVisible(False)
+        hlayout_cmd.addWidget(self.btCancelAreaCreation)
+
+        hlayout_cmd.addItem(QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum))
+
+        self.btDeleteArea = QPushButton("Delete selected modifier", self)
+        self.btDeleteArea.clicked.connect(self.deleteArea)
+        self.btDeleteArea.setVisible(False)
+        self.btDeleteArea.setEnabled(False)
+        hlayout_cmd.addWidget(self.btDeleteArea)
+
+        hlayout_area = QHBoxLayout()
 
         self.lb = QLabel("Modifier")
         self.lb.setVisible(False)
-        self.hlayout.addWidget(self.lb)
+        hlayout_area.addWidget(self.lb)
 
         self.leAreaCode = QLineEdit(self)
         self.leAreaCode.setVisible(False)
-        self.hlayout.addWidget(self.leAreaCode)
+        hlayout_area.addWidget(self.leAreaCode)
 
         self.btColor = QPushButton()
         self.btColor.clicked.connect(self.chooseColor)
         self.btColor.setVisible(False)
-        self.btColor.setStyleSheet("QWidget {{background-color:{}}}".format(self.areaColor.name()))
-        self.hlayout.addWidget(self.btColor)
+        self.btColor.setStyleSheet(f"QWidget {{ background-color:{self.areaColor.name()} }}")
+        hlayout_area.addWidget(self.btColor)
 
         self.slAlpha = QSlider(Qt.Horizontal)
         self.slAlpha.setRange(20, 100)
         self.slAlpha.setValue(50)
         self.slAlpha.valueChanged.connect(self.slAlpha_changed)
         self.slAlpha.setVisible(False)
-        self.hlayout.addWidget(self.slAlpha)
+        hlayout_area.addWidget(self.slAlpha)
 
         self.slAlpha_changed(50)
-        """
-        self.btCancelMap = QPushButton("Cancel modifiers map", self)
-        self.btCancelMap.clicked.connect(self.cancelMap)
-        self.btCancelMap.setVisible(False)
-        """
 
-        layout = QVBoxLayout()
-        layout.addWidget(self.view)
-        layout.addWidget(self.btLoad)
+        vlayout_frame = QVBoxLayout()
+        vlayout_frame.addLayout(hlayout_cmd)
+        vlayout_frame.addLayout(hlayout_area)
+        vlayout_frame.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
 
-        hlayout2 = QHBoxLayout()
-        hlayout2.addWidget(self.btNewArea)
-
-        self.btSaveArea = QPushButton("Save modifier", self)
-        self.btSaveArea.clicked.connect(self.saveArea)
-        self.btSaveArea.setVisible(False)
-        hlayout2.addWidget(self.btSaveArea)
+        frame = QFrame()
+        frame.setFrameStyle(QFrame.Panel | QFrame.Plain)
+        frame.setMinimumHeight(120)
+        frame.setMaximumHeight(120)
 
-        self.btCancelAreaCreation = QPushButton("Cancel new modifier", self)
-        self.btCancelAreaCreation.clicked.connect(self.cancelAreaCreation)
-        self.btCancelAreaCreation.setVisible(False)
-        hlayout2.addWidget(self.btCancelAreaCreation)
+        frame.setLayout(vlayout_frame)
 
-        self.btDeleteArea = QPushButton("Delete selected modifier", self)
-        self.btDeleteArea.clicked.connect(self.deleteArea)
-        self.btDeleteArea.setVisible(True)
-        self.btDeleteArea.setEnabled(False)
-        hlayout2.addWidget(self.btDeleteArea)
+        vlayout = QVBoxLayout()
 
-        layout.addLayout(hlayout2)
-        layout.addLayout(self.hlayout)
-        """layout.addWidget(self.btCancelMap)"""
+        vlayout.addWidget(splitter1)
+        vlayout.addWidget(frame)
 
         main_widget = QWidget(self)
-        main_widget.setLayout(layout)
+        main_widget.setLayout(vlayout)
         self.setCentralWidget(main_widget)
 
         self.statusBar().showMessage("")
 
+    def area_list_item_click(self, item):
+        """
+        select the polygon corresponding to the clicked area
+        """
+
+        if self.selectedPolygon:
+            self.selectedPolygon.setPen(QPen(designColor, penWidth, penStyle, Qt.RoundCap, Qt.RoundJoin))
+            self.selectedPolygon = None
+            self.selectedPolygonMemBrush = None
+
+        modifier_name = item.text()
+
+        self.selectedPolygon = self.polygonsList2[item.text()]
+
+        self.selectedPolygonMemBrush = self.selectedPolygon.brush()
+
+        self.selectedPolygonAreaCode = modifier_name
+
+        self.selectedPolygon.setPen(QPen(QColor(255, 0, 0, 255), 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
+
+        self.leAreaCode.setText(modifier_name)
+        for widget in (self.lb, self.leAreaCode, self.btSaveArea, self.btDeleteArea, self.btColor, self.slAlpha):
+            widget.setVisible(True)
+
+        self.btSaveArea.setText("Update modifier")
+        self.btDeleteArea.setEnabled(True)
+
+        self.areaColor = self.selectedPolygon.brush().color()
+        self.btColor.setStyleSheet(f"QWidget {{background-color:{self.selectedPolygon.brush().color().name()}}}")
+
+        self.slAlpha.setValue(int(self.areaColor.alpha() / 255 * 100))
+
+    def get_current_alpha_value(self) -> str | None:
+        """
+        returns current alpha value (from button text)
+        """
+        match = re.search(r"(\d+)", self.btColor.text())
+
+        if match:
+            opacity_value = int(match.group(1))  # Convert the extracted string to an integer
+            return opacity_value
+        else:
+            return None
+
     def slAlpha_changed(self, val):
         """
         opacity slider value changed
         """
 
-        self.btColor.setText("Opacity: {} %".format(val))
+        self.btColor.setText(f"Opacity: {val}")
         self.areaColor.setAlpha(int(val / 100 * 255))
 
         if self.selectedPolygon:
             self.selectedPolygon.setBrush(self.areaColor)
-            self.areasList[self.leAreaCode.text()]["color"] = self.areaColor.rgba()
+
+            # self.areasList[self.leAreaCode.text()]["color"] = self.areaColor.rgba()
 
         if self.closedPolygon:
             self.closedPolygon.setBrush(self.areaColor)
@@ -244,30 +320,32 @@ class ModifiersMapCreatorWindow(QMainWindow):
         cd.setWindowFlags(Qt.WindowStaysOnTopHint)
         cd.setOptions(QColorDialog.ShowAlphaChannel | QColorDialog.DontUseNativeDialog)
 
-        if cd.exec_():
+        if cd.exec():
             self.areaColor = cd.currentColor()
+            self.areaColor.setAlpha(int(self.get_current_alpha_value() / 100 * 255))
+
             self.btColor.setStyleSheet(f"QWidget {{background-color:{self.areaColor.name()}}}")
 
-        if self.selectedPolygon:
-            self.selectedPolygon.setBrush(self.areaColor)
-            self.areasList[self.leAreaCode.text()]["color"] = self.areaColor.rgba()
+            if self.selectedPolygon:
+                self.selectedPolygon.setBrush(self.areaColor)
+                self.areasList[self.leAreaCode.text()]["color"] = self.areaColor.rgba()
 
-        if self.closedPolygon:
-            self.closedPolygon.setBrush(self.areaColor)
+            if self.closedPolygon:
+                self.closedPolygon.setBrush(self.areaColor)
 
     def closeEvent(self, event):
-        if self.flagMapChanged:
+        if self.flag_map_changed:
             response = dialog.MessageDialog(
                 "BORIS - Modifiers map creator",
                 "What to do about the current unsaved modifiers coding map?",
-                ["Save", "Discard", "Cancel"],
+                [cfg.SAVE, cfg.DISCARD, cfg.CANCEL],
             )
 
-            if response == "Save":
+            if response == cfg.SAVE:
                 if not self.saveMap_clicked():
                     event.ignore()
 
-            if response == "Cancel":
+            if response == cfg.CANCEL:
                 event.ignore()
                 return
 
@@ -279,12 +357,52 @@ class ModifiersMapCreatorWindow(QMainWindow):
         check if area selected with mouse
         """
 
+        def new_polygon():
+            """
+            create a newpolygon
+            """
+            newPolygon = QPolygonF()
+            for p in self.view.points:
+                newPolygon.append(QPoint(p[0], p[1]))
+
+            # draw polygon a red polygon
+            self.closedPolygon = QGraphicsPolygonItem(newPolygon)
+            self.closedPolygon.setPen(QPen(designColor, penWidth, penStyle, Qt.RoundCap, Qt.RoundJoin))
+            self.closedPolygon.setBrush(self.areaColor)
+            self.view.scene().addItem(self.closedPolygon)
+
+        def add_last_line():
+            """
+            add last line to start point
+            """
+            line = QGraphicsLineItem(
+                QLineF(
+                    self.view._start,
+                    QPoint(self.view.points[0][0], self.view.points[0][1]),
+                )
+            )
+            line.setPen(
+                QPen(
+                    designColor,
+                    penWidth,
+                    Qt.SolidLine,
+                    Qt.RoundCap,
+                    Qt.RoundJoin,
+                )
+            )
+
+            self.view.scene().addItem(line)
+            self.view.elList.append(line)
+
+            self.statusBar().showMessage("Area completed")
+
         if not self.bitmapFileName:
             return
 
         self.btDeleteArea.setEnabled(False)
 
-        test = self.view.mapToScene(event.pos()).toPoint()
+        # test = self.view.mapToScene(event.pos()).toPoint()
+        test = self.view.mapToScene(event.position().toPoint()).toPoint()
 
         if test.x() < 0 or test.y() < 0 or test.x() > self.pixmap.size().width() or test.y() > self.pixmap.size().height():
             return
@@ -298,10 +416,12 @@ class ModifiersMapCreatorWindow(QMainWindow):
                 self.selectedPolygon = None
                 self.selectedPolygonMemBrush = None
 
-            for areaCode in self.polygonsList2:
+            for idx, areaCode in enumerate(sorted(self.polygonsList2.keys())):
+                for widget in (self.lb, self.leAreaCode, self.btSaveArea, self.btDeleteArea, self.btColor, self.slAlpha):
+                    widget.setVisible(False)
+
                 if self.polygonsList2[areaCode].contains(test):
-                    if txt:
-                        txt += ","
+                    txt += "," if txt else ""
 
                     txt += areaCode
                     self.selectedPolygon = self.polygonsList2[areaCode]
@@ -320,20 +440,24 @@ class ModifiersMapCreatorWindow(QMainWindow):
                     )
 
                     self.leAreaCode.setText(areaCode)
-                    self.leAreaCode.setVisible(True)
                     self.btDeleteArea.setEnabled(True)
 
+                    # select area in list widget
+                    item = self.area_list.item(idx)
+                    self.area_list.setCurrentItem(item)
+
+                    for widget in (self.lb, self.leAreaCode, self.btSaveArea, self.btDeleteArea, self.btColor, self.slAlpha):
+                        widget.setVisible(True)
+
                     self.areaColor = self.selectedPolygon.brush().color()
-                    self.btColor.setStyleSheet("QWidget {{background-color:{}}}".format(self.selectedPolygon.brush().color().name()))
-                    self.btColor.setVisible(True)
+                    self.btColor.setStyleSheet(f"QWidget {{background-color:{self.selectedPolygon.brush().color().name()} }}")
 
-                    self.slAlpha.setValue(int(self.selectedPolygon.brush().color().alpha() / 255 * 100))
-                    self.slAlpha.setVisible(True)
+                    self.slAlpha.setValue(int(self.areaColor.alpha() / 255 * 100))
 
                     break
 
             if txt:
-                self.statusBar().showMessage("Modifier{}: {}".format("s" if "," in txt else "", txt))
+                self.statusBar().showMessage(f"Modifier{'s' if ',' in txt else ''}: {txt}")
             else:
                 self.statusBar().showMessage("")
 
@@ -343,7 +467,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
                 self.slAlpha.setVisible(False)
             return
 
-        # delete last line item
+        # right button: delete last line item
         if (event.buttons() & Qt.RightButton) and not self.closedPolygon:
             if self.view.points:
                 self.view.points = self.view.points[0:-1]
@@ -358,6 +482,11 @@ class ModifiersMapCreatorWindow(QMainWindow):
                 self.view.scene().removeItem(self.view.elList[-1])
                 self.view.elList = self.view.elList[0:-1]
 
+        # middle button automatically close the polygon
+        if (event.buttons() & Qt.MiddleButton) and not self.closedPolygon:
+            add_last_line()
+            new_polygon()
+
         # add line item
         if event.buttons() == Qt.LeftButton and not self.closedPolygon:
             if self.view._start:
@@ -377,40 +506,8 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
                 # test if polygon closed (dist min 10 px)
                 if abs(end.x() - self.view.points[0][0]) < 10 and abs(end.y() - self.view.points[0][1]) < 10:
-                    line = QGraphicsLineItem(
-                        QLineF(
-                            self.view._start,
-                            QPoint(self.view.points[0][0], self.view.points[0][1]),
-                        )
-                    )
-                    line.setPen(
-                        QPen(
-                            designColor,
-                            penWidth,
-                            Qt.SolidLine,
-                            Qt.RoundCap,
-                            Qt.RoundJoin,
-                        )
-                    )
-
-                    self.view.scene().addItem(line)
-                    self.view.elList.append(line)
-
-                    self.statusBar().showMessage("Area completed")
-
-                    # create polygon
-                    newPolygon = QPolygonF()
-                    for p in self.view.points:
-                        newPolygon.append(QPoint(p[0], p[1]))
-
-                    # draw polygon a red polygon
-                    self.closedPolygon = QGraphicsPolygonItem(newPolygon)
-
-                    self.closedPolygon.setPen(QPen(designColor, penWidth, penStyle, Qt.RoundCap, Qt.RoundJoin))
-
-                    self.closedPolygon.setBrush(self.areaColor)
-
-                    self.view.scene().addItem(self.closedPolygon)
+                    add_last_line()
+                    new_polygon()
 
                     return
 
@@ -454,14 +551,14 @@ class ModifiersMapCreatorWindow(QMainWindow):
         )
         if ok:
             self.mapName = text
-            self.setWindowTitle("{} - Modifiers map creator tool - {}".format(cfg.programName, self.mapName))
+            self.setWindowTitle(f"{cfg.programName} - Modifiers map creator tool - {self.mapName}")
 
     def newMap(self):
         """
         create a new map
         """
 
-        if self.flagMapChanged:
+        if self.flag_map_changed:
             response = dialog.MessageDialog(
                 cfg.programName + " - Modifiers map creator",
                 "What to do about the current unsaved coding map?",
@@ -493,28 +590,25 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         self.setWindowTitle(cfg.programName + " - Map creator tool - " + self.mapName)
 
-        self.btLoad.setVisible(True)
-        """self.btCancelMap.setVisible(True)"""
-
-        self.statusBar().showMessage('Click "Load bitmap" button to select and load a bitmap into the viewer')
+        self.loadBitmap()
 
     def openMap(self):
         """
         load bitmap from data
         show it in view scene
         """
-        if self.flagMapChanged:
+        if self.flag_map_changed:
             response = dialog.MessageDialog(
                 cfg.programName + " - Map creator",
                 "What to do about the current unsaved coding map?",
-                ["Save", "Discard", "Cancel"],
+                (cfg.SAVE, cfg.DISCARD, cfg.CANCEL),
             )
 
-            if response == "Save":
+            if response == cfg.SAVE:
                 if not self.saveMap_clicked():
                     return
 
-            if response == "Cancel":
+            if response == cfg.CANCEL:
                 return
 
         fileName, _ = QFileDialog().getOpenFileName(
@@ -525,14 +619,14 @@ class ModifiersMapCreatorWindow(QMainWindow):
         )
 
         if not fileName:
-            self.statusBar().showMessage("No file", 5000)
+            return
         try:
             self.codingMap = json.loads(open(fileName, "r").read())
         except Exception:
             QMessageBox.critical(
                 self,
                 cfg.programName,
-                "The file {} seems not a behaviors coding map...".format(fileName),
+                f"The file {fileName} seems not a behaviors coding map...",
             )
             return
 
@@ -547,6 +641,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
         self.fileName = fileName
 
         self.areasList = self.codingMap["areas"]  # dictionary of dictionaries
+
         bitmapContent = binascii.a2b_base64(self.codingMap["bitmap"])
 
         self.pixmap.loadFromData(bitmapContent)
@@ -582,44 +677,45 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         self.btNewArea.setVisible(True)
 
-        self.btLoad.setVisible(False)
-
         self.saveMapAction.setEnabled(True)
         self.saveAsMapAction.setEnabled(True)
         self.mapNameAction.setEnabled(True)
-        self.statusBar().showMessage('Click "New area" to create a new area')
 
-    def saveMap(self):
-        if self.fileName:
-            # create dict with map name key
-            mapDict = {"name": self.mapName}
+        self.update_area_list()
 
-            # add areas
-            mapDict["areas"] = self.areasList
+        self.statusBar().showMessage('Click the "New modifier" button to create a new modifier')
 
-            import io
+    def saveMap(self) -> bool:
+        """
+        save the modifier coding map on file
+        """
+        if not self.fileName:
+            return False
+        # create dict with map name key
+        mapDict = {"name": self.mapName}
 
-            # Save QPixmap to QByteArray via QBuffer.
-            byte_array = QByteArray()
-            buffer = QBuffer(byte_array)
-            buffer.open(QIODevice.WriteOnly)
-            self.pixmap.save(buffer, "PNG")
+        # add areas
+        mapDict["areas"] = self.areasList
 
-            string_io = io.BytesIO(byte_array)
+        # Save QPixmap to QByteArray via QBuffer.
+        byte_array = QByteArray()
+        buffer = QBuffer(byte_array)
+        buffer.open(QIODevice.WriteOnly)
+        self.pixmap.save(buffer, "PNG")
 
-            string_io.seek(0)
+        string_io = io.BytesIO(byte_array)
 
-            # add bitmap
-            mapDict["bitmap"] = binascii.b2a_base64(string_io.read()).decode("utf-8")
+        string_io.seek(0)
 
-            with open(self.fileName, "w") as outfile:
-                outfile.write(json.dumps(mapDict))
+        # add bitmap
+        mapDict["bitmap"] = binascii.b2a_base64(string_io.read()).decode("utf-8")
 
-            self.flagMapChanged = False
+        with open(self.fileName, "w") as outfile:
+            outfile.write(json.dumps(mapDict))
 
-            return True
-        else:
-            return False
+        self.flag_map_changed = False
+
+        return True
 
     def saveAsMap_clicked(self):
         filters = "Modifiers map (*.boris_map);;All files (*)"
@@ -657,8 +753,11 @@ class ModifiersMapCreatorWindow(QMainWindow):
         return False
 
     def newArea(self):
+        """
+        create a new area
+        """
         if not self.bitmapFileName:
-            QMessageBox.critical(self, cfg.programName, "A bitmap must be loaded before to define areas")
+            QMessageBox.critical(self, cfg.programName, "An image must be loaded before to define areas")
             return
 
         if self.selectedPolygon:
@@ -666,90 +765,113 @@ class ModifiersMapCreatorWindow(QMainWindow):
             self.selectedPolygon = None
 
         self.flagNewArea = True
-        self.btSaveArea.setVisible(True)
-        self.btCancelAreaCreation.setVisible(True)
-        self.btNewArea.setVisible(False)
-        self.lb.setVisible(True)
         self.leAreaCode.clear()
-        self.leAreaCode.setVisible(True)
-        self.btColor.setVisible(True)
-        self.slAlpha.setVisible(True)
+
+        for widget in (
+            self.btSaveArea,
+            self.btCancelAreaCreation,
+            self.lb,
+            self.leAreaCode,
+            self.btColor,
+            self.slAlpha,
+        ):
+            widget.setVisible(True)
+
+        self.btSaveArea.setText("Save modifier")
+
+        self.btNewArea.setVisible(False)
         self.btDeleteArea.setVisible(False)
 
         self.statusBar().showMessage(
-            "Select the vertices of the area for this modifier with the mouse (right click will cancel the last point)"
+            "Draw a polygon by clicking the vertices (right-click will delete the last point, middle-click will close the polygon)"
         )
 
     def saveArea(self):
-        if not self.closedPolygon:
-            QMessageBox.critical(
-                self,
-                cfg.programName,
-                "You must close your area before saving it.\nThe last vertex must correspond to the first one.",
-            )
-
-        if len(self.view.points) < 3:
-            QMessageBox.critical(self, cfg.programName, "You must define a closed area")
-            return
-
-        # check if no area code
-        if not self.leAreaCode.text():
-            QMessageBox.critical(self, cfg.programName, "You must define a code for the new modifier")
-            return
+        """
+        save the new modifier in the list
+        """
 
         # check if not allowed character
-        for c in "|,()":
+        for c in cfg.CHAR_FORBIDDEN_IN_MODIFIERS:
             if c in self.leAreaCode.text():
                 QMessageBox.critical(
                     self,
                     cfg.programName,
-                    "The modifier contains a character that is not allowed <b>()|,</b>.",
+                    f"The modifier contains a character that is not allowed <b>{cfg.CHAR_FORBIDDEN_IN_MODIFIERS}</b>.",
                 )
                 return
 
-        # check if area code already used
+        # check if modification
+        if "save" in self.btSaveArea.text().lower():
+            if not self.closedPolygon:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "You must close your area before saving it.\nThe last vertex must correspond to the first one.",
+                )
 
-        if self.leAreaCode.text() in self.areasList:
-            QMessageBox.critical(self, cfg.programName, "The modifier is already in use")
-            return
+            if len(self.view.points) < 3:
+                QMessageBox.critical(self, cfg.programName, "You must define a closed area")
+                return
 
-        # create polygon
-        newPolygon = QPolygon()
-        for p in self.view.points:
-            newPolygon.append(QPoint(p[0], p[1]))
+            # check if no modifier name
+            if not self.leAreaCode.text():
+                QMessageBox.critical(self, cfg.programName, "You must define a code for the new modifier")
+                return
 
-        self.areasList[self.leAreaCode.text()] = {
-            "geometry": self.view.points,
-            "color": self.areaColor.rgba(),
-        }
+            # check if modifier name already used
+            if self.leAreaCode.text() in self.areasList:
+                QMessageBox.critical(self, cfg.programName, "The modifier name is already in use")
+                return
 
-        # remove all lines
-        for line in self.view.elList:
-            self.view.scene().removeItem(line)
+            # create polygon
+            newPolygon = QPolygon()
+            for p in self.view.points:
+                newPolygon.append(QPoint(p[0], p[1]))
 
-        # draw polygon
-        self.closedPolygon.setBrush(QBrush(self.areaColor, Qt.SolidPattern))
-        self.polygonsList2[self.leAreaCode.text()] = self.closedPolygon
-        self.closedPolygon = None
-        self.view._start = 0
-        self.view.points = []
-        self.view.elList = []
-        self.flagNewArea = False
-        self.closedPolygon = None
+            self.areasList[self.leAreaCode.text()] = {
+                "geometry": self.view.points,
+                "color": self.areaColor.rgba(),
+            }
 
-        self.btSaveArea.setVisible(False)
-        self.btCancelAreaCreation.setVisible(False)
-        self.lb.setVisible(False)
-        self.leAreaCode.setVisible(False)
-        self.btColor.setVisible(False)
-        self.slAlpha.setVisible(False)
-        self.btDeleteArea.setVisible(True)
-        self.btNewArea.setVisible(True)
+            # remove all lines
+            for line in self.view.elList:
+                self.view.scene().removeItem(line)
 
-        self.leAreaCode.setText("")
+            # draw polygon
+            self.closedPolygon.setBrush(QBrush(self.areaColor, Qt.SolidPattern))
+            self.polygonsList2[self.leAreaCode.text()] = self.closedPolygon
+            self.closedPolygon = None
+            self.view._start = 0
+            self.view.points = []
+            self.view.elList = []
+            self.flagNewArea = False
+
+            self.statusBar().showMessage("New modifier saved", 5000)
+
+        else:  # modification
+            if self.leAreaCode.text() not in self.polygonsList2:
+                self.polygonsList2[self.leAreaCode.text()] = self.polygonsList2.pop(self.area_list.currentItem().text())
+                self.polygonsList2[self.leAreaCode.text()].setBrush(self.areaColor)
+
+            self.statusBar().showMessage("Modifier modified", 5000)
+
+        for widget in (
+            self.btSaveArea,
+            self.btCancelAreaCreation,
+            self.lb,
+            self.leAreaCode,
+            self.btColor,
+            self.slAlpha,
+            self.btDeleteArea,
+            self.btNewArea,
+        ):
+            widget.setVisible(False)
 
-        self.flagMapChanged = True
-        self.statusBar().showMessage("New modifier saved", 5000)
+        self.btNewArea.setVisible(True)
+        self.leAreaCode.setText("")
+        self.update_area_list()
+        self.flag_map_changed = True
 
     def cancelAreaCreation(self):
         if self.closedPolygon:
@@ -777,6 +899,17 @@ class ModifiersMapCreatorWindow(QMainWindow):
         self.leAreaCode.setVisible(False)
         self.leAreaCode.setText("")
 
+    def update_area_list(self):
+        """
+        update the area list widget
+        """
+        self.area_list.clear()
+
+        print(f"{self.polygonsList2=}")
+
+        for modifier_name in sorted(self.polygonsList2.keys()):
+            self.area_list.addItem(modifier_name)
+
     def deleteArea(self):
         """
         remove selected area from map
@@ -784,27 +917,32 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         if self.selectedPolygon:
             self.view.scene().removeItem(self.selectedPolygon)
-            self.view.scene().removeItem(self.polygonsList2[self.selectedPolygonAreaCode])
 
-            del self.polygonsList2[self.selectedPolygonAreaCode]
-            del self.areasList[self.selectedPolygonAreaCode]
+            if self.selectedPolygonAreaCode:
+                self.view.scene().removeItem(self.polygonsList2[self.selectedPolygonAreaCode])
+                del self.polygonsList2[self.selectedPolygonAreaCode]
+                del self.areasList[self.selectedPolygonAreaCode]
 
-            self.flagMapChanged = True
+            self.selectedPolygonAreaCode = None
+            self.selectedPolygon = None
+
+            self.flag_map_changed = True
 
         self.view.elList = []
 
         self.view._start = 0
         self.view.points = []
         self.flagNewArea = False
-        self.btSaveArea.setVisible(False)
-        self.lb.setVisible(False)
 
-        self.btColor.setVisible(False)
-        self.slAlpha.setVisible(False)
+        for widget in (self.btSaveArea, self.lb, self.btColor, self.slAlpha, self.leAreaCode):
+            widget.setVisible(False)
+
         self.btNewArea.setVisible(True)
 
-        self.leAreaCode.setVisible(False)
         self.leAreaCode.setText("")
+        self.statusBar().showMessage("")
+
+        self.update_area_list()
 
     def cancelMap(self):
         """
@@ -814,23 +952,19 @@ class ModifiersMapCreatorWindow(QMainWindow):
         self.areasList = {}
         self.polygonsList2 = {}
         self.view.scene().clear()
-        self.btLoad.setVisible(False)
         self.btDeleteArea.setVisible(False)
         self.btNewArea.setVisible(False)
         self.saveMapAction.setEnabled(False)
         self.saveAsMapAction.setEnabled(False)
         self.mapNameAction.setEnabled(False)
         self.statusBar().showMessage("")
-        self.flagMapChanged = False
+        self.flag_map_changed = False
 
     def loadBitmap(self):
         """
         load bitmap as background for coding map
-        resize bitmap to 512 px if bigger
         """
 
-        maxSize = 512
-
         fileName, _ = QFileDialog().getOpenFileName(self, "Load bitmap", "", "bitmap files (*.png *.jpg);;All files (*)")
 
         if not fileName:
@@ -839,6 +973,8 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         self.pixmap.load(self.bitmapFileName)
 
+        # scale image
+        """
         if self.pixmap.size().width() > maxSize or self.pixmap.size().height() > maxSize:
             self.pixmap = self.pixmap.scaled(maxSize, maxSize, Qt.KeepAspectRatio)
             QMessageBox.information(
@@ -847,9 +983,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
                 "The bitmap was resized to %d x %d pixels\nThe original file was not modified"
                 % (self.pixmap.size().width(), self.pixmap.size().height()),
             )
-
-        # scale image
-        # pixmap = pixmap.scaled (256, 256, Qt.KeepAspectRatio)
+        """
 
         self.view.setSceneRect(0, 0, self.pixmap.size().width(), self.pixmap.size().height())
         pixitem = QGraphicsPixmapItem(self.pixmap)
@@ -858,14 +992,13 @@ class ModifiersMapCreatorWindow(QMainWindow):
 
         self.btNewArea.setVisible(True)
 
-        self.btLoad.setVisible(False)
         self.saveMapAction.setEnabled(True)
         self.saveAsMapAction.setEnabled(True)
         self.mapNameAction.setEnabled(True)
 
         self.statusBar().showMessage("""Click "New modifier" to create a new modifier""")
 
-        self.flagMapChanged = True
+        self.flag_map_changed = True
 
 
 if __name__ == "__main__":
@@ -873,6 +1006,25 @@ if __name__ == "__main__":
 
     app = QApplication(sys.argv)
     window = ModifiersMapCreatorWindow()
-    window.resize(640, 640)
+    window.resize(800, 700)
+
+    print(f"{window.width()=}")
+    print(f"{window.height()=}")
+
+    # Get the screen geometry (screen size and position)
+    screen_geometry = app.primaryScreen().geometry()
+
+    print(f"{screen_geometry=}")
+
+    # Calculate the center of the screen
+    center_x = (screen_geometry.width() - window.width()) // 2
+    center_y = (screen_geometry.height() - window.height()) // 2
+
+    print(f"{center_x=}")
+    print(f"{center_y=}")
+
+    # Move the widget to the center of the screen
+    window.move(center_x, center_y)
+
     window.show()
-    sys.exit(app.exec_())
+    sys.exit(app.exec())