wolfhece 2.0.17__py3-none-any.whl → 2.0.19__py3-none-any.whl

wolfhece/CpGrid.py

@@ -4,19 +4,16 @@ import wx.grid
 from .PyTranslate import _
 
 class CpGrid(wx.grid.Grid):
-    """ A Full Copy and Paste enabled grid class which implements Excel
-    like copy, paste, and delete functionality.
-
-    Ctrl+c - Copy range of selected cells.
-    Ctrl+v - Paste copy selection at point of currently selected cell.
-             If paste selection is larger than copy selection,
-             copy selection will be replicated to fill paste
-             region if it is a modulo number of copy rows and/or
-             columns, otherwise just the copy selection will be pasted.
-    Ctrl+x - Delete current selection. Deleted selection can be
-             restored with Ctrl+z, or pasted with Ctrl+v.
-             Delete or backspace key will also perform this action.
-    Ctrl+z - Undo the last paste or delete action.
+    """
+    A Full Copy and Paste enabled grid class which implements Excel like copy, paste, and delete functionality.
+
+        - Ctrl+c : Copy range of selected cells.
+        - Ctrl+v : Paste copy selection at point of currently selected cell.
+        - If paste selection is larger than copy selection, copy selection will be replicated to fill paste region if it is a modulo number of copy rows and/or columns, otherwise just the copy selection will be pasted.
+        - Ctrl+x : Delete current selection.
+        - Deleted selection can be restored with Ctrl+z, or pasted with Ctrl+v.
+        - Delete or backspace key will also perform this action.
+        - Ctrl+z : Undo the last paste or delete action.
 
     """
 

wolfhece/PyCrosssections.py

@@ -393,7 +393,7 @@ class profile(vector):
                               self.myvertices[-1].y-self.myvertices[0].y])
         self.orient = self.orient /np.linalg.norm(self.orient)
 
-    def get_xy_from_s(self,s) -> (float, float):
+    def get_xy_from_s(self,s) -> tuple[float, float]:
         """
         Récupération d'un tuple (x,y) sur base d'une distance 2D 's' orientée dans l'axe de la section
         """
@@ -672,7 +672,7 @@ class profile(vector):
 
         return length
 
-    def get_sz(self, cumul=True) -> (np.ndarray, np.ndarray):
+    def get_sz(self, cumul=True) -> tuple[np.ndarray, np.ndarray]:
         """
         Retourne 2 vecteurs avec la position curvi 2D et l'altitude des points
         """
@@ -729,7 +729,7 @@ class profile(vector):
             curvert = wolfvertex(xy[i,0],xy[i,1],sz[i,1])
             self.add_vertex(curvert)
 
-    def get_sz_banksbed(self, cumul=True, force:bool=False) -> (float, float, float, float, float, float):
+    def get_sz_banksbed(self, cumul=True, force:bool=False) -> tuple[float, float, float, float, float, float]:
         """
         Retourne les positions des points de référence  mais avec la coordonnée curvi 2D
          - (sleft, sbed, sright, zleft, zbed, zright)
@@ -791,10 +791,10 @@ class profile(vector):
 
         return sleft,sbed,sright,zleft,zbed,zright
 
-    def get_s3d_banksbed(self, force:bool=False)-> (float, float, float):
+    def get_s3d_banksbed(self, force:bool=False)-> tuple[float, float, float]:
         """
         Retourne les coordonnée curvi 3D des points de référence
-         - (sleft, sbed, sright)
+        - (sleft, sbed, sright)
         """
 
         if self.prepared and not force:
@@ -1678,11 +1678,11 @@ class crosssections(Element_To_Draw):
 
     L'objet stocke ses informations dans un dictionnaire : self.myprofiles
     Les clés de chaque entrée sont:
-        ['index']   : integer
-        ['left']    : wolfvertex
-        ['bed']     : wolfvertex
-        ['right']   : wolfvertex
-        ['cs']      : profile (surcharge de vector)
+        - ['index']   : integer
+        - ['left']    : wolfvertex
+        - ['bed']     : wolfvertex
+        - ['right']   : wolfvertex
+        - ['cs']      : profile (surcharge de vector)
 
     Pour le moment, il est possible de lire les fichiers et d'effectuer cerrains traitements (tri selon vecteur, export gltf...).
 
@@ -1694,6 +1694,7 @@ class crosssections(Element_To_Draw):
             - cloud_all
 
     @remark !! La classe n'est pas encore prévue pour créer des sections en travers!!
+
     """
 
     myprofiles:dict
@@ -2419,8 +2420,10 @@ class crosssections(Element_To_Draw):
         self.multils = self.asshapely_ls()
 
     def sort_along(self,vecsupport:LineString,name:str,downfirst=True):
-        """Sélectionne les sections qui intersectent un vecteur support
-        et les trie selon l'abscisse curviligne"""
+        """
+        Sélectionne les sections qui intersectent un vecteur support
+        et les trie selon l'abscisse curviligne
+        """
 
         curdict = self.sorted[name]={}
         curdict['support'] = vecsupport
@@ -2989,7 +2992,9 @@ class Interpolator():
         return xy,z
 
 class Interpolators():
-    """ Classe de gestion des interpolations sur sections en travers """
+    """
+    Classe de gestion des interpolations sur sections en travers
+    """
 
     def __init__(self, banks:Zones, cs:crosssections, ds=1.) -> None:
         """

wolfhece/PyDraw.py

@@ -1002,10 +1002,20 @@ class WolfMapViewer(wx.Frame):
             self.active_array.interpolate_on_triangulation(self.active_tri.pts, self.active_tri.tri, )
 
     def compare_cloud2array(self):
+        """
+        Compare the active cloud points to the active array
+
+        """
+
+        if self.active_array is None :
+            logging.warning(_('No active array -- Please activate an array first'))
+            return
 
-        if self.active_array is not None and self.active_cloud is not None:
+        if self.active_cloud is None:
+            logging.warning(_('No active cloud -- Please activate a cloud first'))
+            return
 
-            self.active_array.compare_cloud(self.active_cloud)
+        self.active_array.compare_cloud(self.active_cloud)
 
     def compare_tri2array(self):
 
@@ -1748,7 +1758,8 @@ class WolfMapViewer(wx.Frame):
                                '2012-2013': 'ORTHO_2012_2013',
                                '2015': 'ORTHO_2015', '2016': 'ORTHO_2016', '2017': 'ORTHO_2017',
                                '2018': 'ORTHO_2018', '2019': 'ORTHO_2019', '2020': 'ORTHO_2020',
-                               '2021': 'ORTHO_2021'}}
+                               '2021': 'ORTHO_2021', '2022 printemps': 'ORTHO_2022_PRINTEMPS', '2022 été': 'ORTHO_2022_ETE',
+                               '2023 été': 'ORTHO_2023_ETE'}}
         for idx, (k, item) in enumerate(orthos.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
                 self.add_object(which='wmsback',
@@ -2429,6 +2440,13 @@ class WolfMapViewer(wx.Frame):
                     else:
                         logging.info(_('Bad parameter in project file - array : ')+ curname[key_Param.VALUE])
 
+            if 'cloud' in myproject.myparams.keys():
+                for curid, curname in zip(myproject.myparams['cloud'].keys(), myproject.myparams['cloud'].values()):
+                    if exists(curname[key_Param.VALUE]):
+                        mycloud = cloud_vertices(curname[key_Param.VALUE])
+                        self.add_object('cloud', newobj=mycloud, id=curid)
+                    else:
+                        logging.info(_('Bad parameter in project file - cloud : ')+ curname[key_Param.VALUE])
 
             if 'wolf2d' in myproject.myparams.keys():
                 for curid, curname in zip(myproject.myparams['wolf2d'].keys(), myproject.myparams['wolf2d'].values()):
@@ -3005,15 +3023,66 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _("Plot active vector..."):
 
+
             if self.active_vector is None:
+                logging.warning(_('No active vector !'))
                 return
 
+            add_cloud = False
+            if self.active_cloud is not None:
+                dlg = wx.MessageDialog(self, _('Do you want to plot the cloud ?'), style=wx.YES_NO)
+
+                if dlg.ShowModal() == wx.ID_YES:
+                    add_cloud = True
+
+                    prox = wx.TextEntryDialog(None,_('Proximity [m] ?'), value = '5.0')
+                    ret = prox.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        prox.Destroy()
+                        return
+                    try:
+                        proxval = float(prox.GetValue())
+                    except:
+                        prox.Destroy()
+                        logging.warning(_('Bad value -- Rety'))
+                        return
+
+                    tol = wx.TextEntryDialog(None,_('Tolerance [m] ?'), value = '0.5')
+                    ret = tol.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        tol.Destroy()
+                        return
+                    try:
+                        tolval = float(tol.GetValue())
+                    except:
+                        tol.Destroy()
+                        logging.warning(_('Bad value -- Rety'))
+                        return
+
+                else:
+                    add_cloud = False
+
+                dlg.Destroy()
+
             fig, ax = self.active_vector.plot_mpl(True, False)
 
             linkedarrays = self.get_linked_arrays()
 
             self.active_vector.plot_linked(fig, ax, linkedarrays)
 
+            if add_cloud:
+                s, z = self.active_cloud.projectontrace(self.active_vector, return_cloud=False, proximity= proxval)
+
+                ax.scatter( s, z, c='black', s=1.0)
+
+                for curs, curz in zip(s,z):
+                    ax.plot([curs, curs], [curz-tolval, curz+tolval], 'k--', linewidth=0.5)
+                    ax.plot([curs-.1, curs+.1], [curz+tolval, curz+tolval], c='black', linewidth=0.5)
+                    ax.plot([curs-.1, curs+.1], [curz-tolval, curz-tolval], c='black', linewidth=0.5)
+
+                fig.canvas.draw()
+                fig.canvas.flush_events()
+
         elif itemlabel == _("Export arrays as Geotif..."):
 
             self.export_results_as('geotiff')
@@ -4268,9 +4337,10 @@ class WolfMapViewer(wx.Frame):
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"
         filterVector = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
-        filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|all (*.*)|*.*"
+        filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|shp (*.shp)|*.shp|all (*.*)|*.*"
         filtertri = "tri (*.tri)|*.tri|text (*.txt)|*.txt|dxf (*.dxf)|*.dxf|gltf (*.gltf)|*.gltf|gltf binary (*.glb)|*.glb|*.*'all (*.*)|*.*"
         filterCs = "vecz WOLF (*.vecz)|*.vecz|txt 2022 (*.txt)|*.txt|WOLF (*.sxy)|*.sxy|text 2000 (*.txt)|*.txt|all (*.*)|*.*"
+        filterimage = "Geotif (*.tif)|*.tif|all (*.*)|*.*"
 
         if filename == '' and newobj is None:
             # ouverture d'une boîte de dialogue
@@ -4303,9 +4373,9 @@ class WolfMapViewer(wx.Frame):
 
             # FIXME : particularize filters for wmsback and wmsfore
             elif which.lower() == 'wmsback':
-                file = wx.FileDialog(self, "Choose file", wildcard=filterCloud)
+                file = wx.FileDialog(self, "Choose file", wildcard=filterimage)
             elif which.lower() == 'wmsfore':
-                file = wx.FileDialog(self, "Choose file", wildcard=filterCloud)
+                file = wx.FileDialog(self, "Choose file", wildcard=filterimage)
 
             if file.ShowModal() == wx.ID_CANCEL:
                 file.Destroy()
@@ -4718,12 +4788,13 @@ class WolfMapViewer(wx.Frame):
             newobj.mapviewer = self
 
         elif which.lower() == 'cloud':
+
             curdict = self.myclouds
             curtree = self.myitemscloud
             if newobj is None:
 
                 loadhead = False
-                if not filename.endswith('.dxf'):
+                if not filename.endswith('.dxf') and not filename.endswith('.shp'):
                     with open(filename,'r') as f:
                         text=f.read().splitlines()
                         tmphead=''
@@ -4738,7 +4809,7 @@ class WolfMapViewer(wx.Frame):
 
                 with wx.lib.busy.BusyInfo(_('Importing cloud points')):
                     wait = wx.BusyCursor()
-                    newobj = cloud_vertices(filename,header=loadhead)
+                    newobj = cloud_vertices(filename, header=loadhead)
                     del wait
 
             self.myclouds.append(newobj)
@@ -6681,6 +6752,7 @@ class WolfMapViewer(wx.Frame):
                 self.active_tile = None
                 self.active_particle_system = None
                 self.active_vertex = None
+                self.active_cloud = None
 
             elif key == ord('C'):
 

wolfhece/PyHydrographs.py

@@ -86,8 +86,8 @@ class Hydrograph(pd.Series):
         """
         Read a wolf file at the format infil[n].tv and
         return its data as a dictionnary where:
-         - keys are times and,
-         - values are discharges.
+            - keys are times and
+            - values are discharges
 
         """
         data = {}

wolfhece/PyParams.py

@@ -110,10 +110,9 @@ class Wolf_Param(wx.Frame):
     **FR**
         Gestion des paramètres au format WOLF.
 
-        Fichier texte
-        -------------
+        **Fichier texte**
 
-        Les fichiers '*.param' sont des fichiers texte contenant des paramètres de type nom=valeur et compatibles avec les codes Fortran.
+        Les fichiers '.param' sont des fichiers texte contenant des paramètres de type nom=valeur et compatibles avec les codes Fortran.
         L'extension '.param.default' est utilisée pour stocker les paramètres par défaut.
 
         Une autre extension est possible mais un fichier '.default' sera créé automatiquement si ce fichier n'existe pas.
@@ -124,8 +123,7 @@ class Wolf_Param(wx.Frame):
 
         Les lignes débutant par '%' sont des commentaires. Il est possible d'ajouter du code JSON dans un commentaire. Pour cela, il faut ajouter '%json' au début de la ligne suivi d'un dictionnaire (e.g. %json{"Values":{'key1':1, 'key2':2}, "Full_Comment":"fullcomment"} ).
 
-        Organisation Python
-        -------------------
+        **Organisation Python**
 
         L'objet Python est basé sur des dictionnaires Python. Un dictionnaire par groupe de paramètres.
 
@@ -138,14 +136,12 @@ class Wolf_Param(wx.Frame):
             - comment : commentaire du paramètre (str) -- helpful to understand the parameter
             - added_json : dictionnaire contenant des informations supplémentaires (optionnel) -- permet de stocker des informations supplémentaires sur le paramètre (ex : valeurs possibles, commentaires étendus, ...)
 
-        Dictionnaires
-        -------------
+        **Dictionnaires**
 
         Il existe un dictionnaire de valeurs par défaut "myparams_default". Pour l'interaction Python-Fortran, c'est le Fortran qui écrit ces paramètres.
         Il existe un dictionnaire de paramètres actifs "myparams". Il est utilisé pour stocker les paramètres modifiés par l'utilisateur. Normalement, seuls les paramètres modifiés par l'utilisateur sont stockés dans ce dictionnaire et sont écrits sur disque.
 
-        Groupe/Paramètre incrémentable
-        ------------------------------
+        **Groupe/Paramètre incrémentable**
 
         Il est également possible de définir des groupes ou des paramètres incrémentables.
         Pour cela, dans le nom du groupe/paramètre, il faut ajouter, à l'emplacement souhaité du **numéro** du groupe/paramètre, des informations entre '$...$' :
@@ -160,14 +156,12 @@ class Wolf_Param(wx.Frame):
 
         Les informations génériques sont stockées dans les dictionnaires "myIncGroup" et "myIncParam".
 
-        UI
-        --
+        **UI**
 
         Une interface graphique est disponible pour modifier les paramètres. Elle est basée sur "wxPython" et la classe "wxPropertyGrid".
         L'attribut wx_exists permet de savoir si wxPython est en cours d'excution ou non.
 
-        Accès aux données
-        -----------------
+        **Accès aux données**
 
         Les paramètres sont accessibles via la procédure __getitem__ en fournissant un tuple (groupname, paramname).
         Il est possible de modifier un paramètre via la procédure __setitem__.
@@ -186,10 +180,9 @@ class Wolf_Param(wx.Frame):
     **EN**
         Management of parameters in WOLF format.
 
-        Text File
-        ----------
+        **Text File**
 
-        '*.param' files are text files containing parameters in the name=value format and compatible with Fortran codes.
+        '.param' files are text files containing parameters in the name=value format and compatible with Fortran codes.
         The '.param.default' extension is used to store default parameters.
 
         Another extension is possible, but a '.default' file will be automatically created if this file does not exist.
@@ -200,8 +193,7 @@ class Wolf_Param(wx.Frame):
 
         Lines starting with '%' are comments. It is possible to add JSON code in a comment. To do this, add '%json' at the beginning of the line followed by a dictionary (e.g., %json{"Values":{'key1':1, 'key2':2}, "Full_Comment":"fullcomment"}).
 
-        Python Organization
-        -------------------
+        **Python Organization**
 
         The Python object is based on Python dictionaries. One dictionary per parameter group.
 
@@ -214,14 +206,12 @@ class Wolf_Param(wx.Frame):
             - comment: parameter comment (str) -- helpful to understand the parameter
             - added_json: dictionary containing additional information (optional) -- used to store additional information about the parameter (e.g., possible values, extended comments, ...)
 
-        Dictionaries
-        -------------
+        **Dictionaries**
 
         There is a default values dictionary "myparams_default." For Python-Fortran interaction, Fortran writes these parameters.
         There is an active parameters dictionary "myparams." It is used to store parameters modified by the user. Normally, only parameters modified by the user are stored in this dictionary and written to disk.
 
-        Incrementable Group/Parameter
-        ------------------------------
+        **Incrementable Group/Parameter**
 
         It is also possible to define incrementable groups or parameters.
         To do this, in the group/parameter name, add information between '$...$' at the desired **number** location of the group/parameter:
@@ -236,14 +226,12 @@ class Wolf_Param(wx.Frame):
 
         Generic information is stored in the "myIncGroup" and "myIncParam" dictionaries.
 
-        UI
-        --
+        **UI**
 
         A graphical interface is available to modify parameters. It is based on "wxPython" and the "wxPropertyGrid" class.
         The wx_exists attribute indicates whether wxPython is currently running or not.
 
-        Data Access
-        -----------------
+        **Data Access**
 
         Parameters are accessible via the __getitem__ method by providing a tuple (groupname, paramname).
         It is possible to modify a parameter via the __setitem__ method.
@@ -258,7 +246,7 @@ class Wolf_Param(wx.Frame):
                 - for an incrementable parameter, by providing the necessary data in a string $n(refname,min,max)$ or $n(groupname,refname,min,max)$
                 - if the targeted group does not exist, it will be created if all information is available.
             - only add an incrementable parameter via the add_IncParam method.
-```
+
     """
 
     # Définition des propriétés
@@ -283,7 +271,8 @@ class Wolf_Param(wx.Frame):
                  withbuttons: bool = True,
                  DestroyAtClosing:bool = True,
                  toShow:bool = True,
-                 init_GUI:bool = True):
+                 init_GUI:bool = True,
+                 force_even_if_same_default:bool = False):
         """
         Initialisation
 
@@ -297,7 +286,7 @@ class Wolf_Param(wx.Frame):
         :param withbuttons : if True, buttons will be displayed
         :param DestroyAtClosing : if True, the frame will be destroyed when closed
         :param toShow : if True, the frame will be displayed
-
+        :param force_even_if_same_default : if True, the parameter will be displayed even if the default and active parameters are the same
 
         Callbacks (see 'set_callbacks'):
             - callback : callback function when 'apply' is pressed
@@ -317,7 +306,7 @@ class Wolf_Param(wx.Frame):
         self._callbackdestroy:function = None
 
         self.wx_exists = wx.App.Get() is not None # test if wx App is running
-        self.show_in_active_if_default = False
+        self.show_in_active_if_default = force_even_if_same_default
 
         if to_read:
             self.ReadFile(filename)
@@ -469,6 +458,8 @@ class Wolf_Param(wx.Frame):
         self.SetAutoLayout(1)
         self.sizer.Fit(self)
 
+        self.SetSize(0,0,w,h)
+
         #affichage de la page
         self.Show(toShow)
 
@@ -530,9 +521,13 @@ class Wolf_Param(wx.Frame):
                 page_active.Append(pg.PropertyCategory(groupname))
 
             #teste si param existe
-            if not self.is_in_active(groupname, paramname):
+            activeprop = self.prop.GetPropertyByName(groupname + paramname)
+            if activeprop is None:
                 #si non existant --> on ajoute, si existant --> rien à faire
-                self._add_elem_to_page(page_active, groupname, param_def)
+                self._insert_elem_to_page(page_active, groupname, param_def)
+            # if not self.is_in_active(groupname, paramname):
+            #     #si non existant --> on ajoute, si existant --> rien à faire
+            #     self._add_elem_to_page(page_active, groupname, param_def)
 
         else:
             #recopiage de la valeur par défaut
@@ -583,6 +578,16 @@ class Wolf_Param(wx.Frame):
         # populate the property grid
         self.Populate()
 
+    def _get_prop_names(self, page:pg.PropertyGridPage) -> list[str]:
+        """ Return the names of the properties in a page """
+
+        return [prop.GetName() for prop in page.GetPyIterator(pg.PG_ITERATE_ALL)]
+
+    def _is_in_propperty_page(self, page:pg.PropertyGridPage, group:str, param:str="") -> bool:
+        """ Test if a parameter is in a page """
+
+        return (group + param) in self._get_prop_names(page)
+
     def ApplytoMemory(self, event:wx.MouseEvent):
         """ Transfert des données en mémoire --> remplissage des dictionnaires """
 
@@ -597,7 +602,19 @@ class Wolf_Param(wx.Frame):
             if not self._callback is None:
                 self._callback()
         else:
-            wx.MessageDialog(self,'Nothing to do!')
+            if self.wx_exists:
+                dlg = wx.MessageDialog(self,'Nothing to do!')
+                dlg.ShowModal()
+
+    @property
+    def page_active(self) -> pg.PropertyGridPage:
+        """ Return the active page """
+        return self.prop.GetPage(0)
+
+    @property
+    def page_default(self) -> pg.PropertyGridPage:
+        """ Return the default page """
+        return self.prop.GetPage(1)
 
     def _Apply1ParamtoMemory(self,
                              group:str,
@@ -637,7 +654,8 @@ class Wolf_Param(wx.Frame):
             val_default = self.prop.GetPropertyByName(PREFIX_DEFAULT + group + param_name).m_value
 
             # on tente de rcupérer la valeur active mais il ets possible qu'elle n'existe pas si sa valeur est identique à la valeur par défaut
-            if self.is_in_active(group, param_name):
+            if self._is_in_propperty_page(self.page_active, group, param_name):
+            # if self.is_in_active(group, param_name):
                 val_active  = self.prop.GetPropertyByName(group + param_name).m_value
             else:
                 val_active = val_default
@@ -653,7 +671,8 @@ class Wolf_Param(wx.Frame):
         else:
             # La valeur par défaut n'existe pas --> on prend la valeur active car c'est certainement une valeur incrémentable ou d'un groupe incrémentable
             # Si la valeur n'est pas présente, on ne fait rien
-            if self.is_in_active(group, param_name):
+            if self._is_in_propperty_page(self.page_active, group, param_name):
+            # if self.is_in_active(group, param_name):
                 val_active  = self.prop.GetPropertyByName(group + param_name).m_value
                 val_active  = self.value_as_type(val_active, dict_param_def[key_Param.TYPE])
 
@@ -687,7 +706,9 @@ class Wolf_Param(wx.Frame):
 
         #gestion des paramètres actifs
         for group, params in self.myparams.items():
+
             page_active.Append(pg.PropertyCategory(group))
+
             for param_name, param in params.items():
                 param:dict
                 if self.is_in_default(group, param_name):
@@ -713,6 +734,63 @@ class Wolf_Param(wx.Frame):
         self.prop.ShowHeader()
         self.prop.Refresh()
 
+    def _insert_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
+        """ Insert an element to a page """
+
+        param_name = param[key_Param.NAME]
+        locname = prefix + group + param_name
+
+        # Get parent item based on group name
+        parent = page.GetPropertyByName(group)
+        assert parent is not None, "Group {} not found in page".format(group)
+        assert isinstance(parent, pg.PropertyCategory), "Parent is not a PropertyCategory"
+
+        if param_def is not None:
+            # priority to default parameters
+            if key_Param.ADDED_JSON in param_def.keys():
+                param[key_Param.ADDED_JSON] = param_def[key_Param.ADDED_JSON]
+            param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
+            param[key_Param.TYPE] = param_def[key_Param.TYPE]
+
+        if key_Param.ADDED_JSON in param.keys() and param[key_Param.ADDED_JSON] is not None:
+            # Ajout des choix via chaîne JSON
+            list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
+            list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
+
+            page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(param[key_Param.VALUE])))
+
+            self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]['Full_Comment'])
+        else:
+
+            locvalue = self[(group, param_name)]
+
+            if isinstance(locvalue, float):
+                page.AppendIn(parent, pg.FloatProperty(label = param_name, name = locname, value = locvalue))
+
+            elif isinstance(locvalue, int):
+                # bool is also an int
+                if isinstance(locvalue, bool):
+                    page.AppendIn(parent, pg.BoolProperty(label=param_name, name = locname, value = locvalue))
+                else:
+                    page.AppendIn(parent, pg.IntProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.File:
+                page.AppendIn(parent, pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+
+            elif param[key_Param.TYPE]==Type_Param.Directory:
+                page.AppendIn(parent, pg.DirProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.Color:
+                page.AppendIn(parent, pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.Fontname:
+                page.AppendIn(parent, pg.FontProperty(label = param_name, name = locname, value = locvalue))
+
+            else:
+                page.AppendIn(parent, pg.StringProperty(label = param_name, name = locname, value = locvalue))
+
+            self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
+
     def _add_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
         """ Add an element to a page """