Merge develop into amdadev

Benjamin Renard
2 parents 02d7d98e 8202e86e
Showing 5 changed files with 502 additions and 106 deletions Show diff stats
js/app/models/PlotObjects/PlotObjectConfig.js
js/app/views/PlotComponents/PlotZoomPlug.js
js/app/views/PlotComponents/plotFunction/FunctionType.js
js/app/views/PlotComponents/plotFunction/ParamField.js
js/app/views/PlotTabResultUI.js
@@ -143,7 +143,7 @@ Ext.define(&#39;amdaPlotObj.PlotObjectConfig&#39;, {
 			yAxis: 'y-left',
 			resolution: 3000
 		},
-                		sauvaud: {
+		sauvaud: {
 			yAxis: 'y-right',
 			resolution: 3000
 		},
@@ -375,22 +375,22 @@ Ext.define(&#39;amdaPlotObj.PlotObjectConfig&#39;, {
 	],
  
 	availableColorsNew: [
- "#000000", "#0000ff", "#ff0000", "#00ffff", "#ff00ff", "#008000", "#800000", 
- "#000080", "#808000", "#800080", "#c0c0c0", "#008080", "#ffff00", "#004040", 
- "#29d8d7", "#6b9842", "#73a9b4", "#1c883d", "#808080", "#4342dd", "#e84130",
- "#dee2e6", "#ced4da", "#adb5bd", "#868e96", "#495057", "#343a40", "#212529",
- "#ffa8a8", "#ff8787", "#ff6b6b", "#fa5252", "#f03e3e", "#e03131", "#c92a2a",
- "#faa2c1", "#f783ac", "#f06595", "#e64980", "#d6336c", "#c2255c", "#a61e4d",
- "#e599f7", "#da77f2", "#cc5de8", "#be4bdb", "#ae3ec9", "#9c36b5", "#862e9c",
- "#b197fc", "#9775fa", "#845ef7", "#7950f2", "#7048e8", "#6741d9", "#5f3dc4",
- "#91a7ff", "#748ffc", "#5c7cfa", "#4c6ef5", "#4263eb", "#3b5bdb", "#364fc7",
- "#74c0fc", "#4dabf7", "#339af0", "#228be6", "#1c7ed6", "#1971c2", "#1864ab",
- "#66d9e8", "#3bc9db", "#22b8cf", "#15aabf", "#1098ad", "#0c8599", "#0b7285",
- "#63e6be", "#38d9a9", "#20c997", "#12b886", "#0ca678", "#099268", "#087f5b",
- "#8ce99a", "#69db7c", "#51cf66", "#40c057", "#37b24d", "#2f9e44", "#2b8a3e",
- "#c0eb75", "#a9e34b", "#94d82d", "#82c91e", "#74b816", "#66a80f", "#5c940d",
- "#ffe066", "#ffd43b", "#fcc419", "#fab005", "#f59f00", "#f08c00", "#e67700",
- "#ffc078", "#ffa94d", "#ff922b", "#fd7e14", "#f76707", "#e8590c", "#d9480f"
+		"#000000", "#0000ff", "#ff0000", "#00ffff", "#ff00ff", "#008000", "#800000",
+		"#000080", "#808000", "#800080", "#c0c0c0", "#008080", "#ffff00", "#004040",
+		"#29d8d7", "#6b9842", "#73a9b4", "#1c883d", "#808080", "#4342dd", "#e84130",
+		"#dee2e6", "#ced4da", "#adb5bd", "#868e96", "#495057", "#343a40", "#212529",
+		"#ffa8a8", "#ff8787", "#ff6b6b", "#fa5252", "#f03e3e", "#e03131", "#c92a2a",
+		"#faa2c1", "#f783ac", "#f06595", "#e64980", "#d6336c", "#c2255c", "#a61e4d",
+		"#e599f7", "#da77f2", "#cc5de8", "#be4bdb", "#ae3ec9", "#9c36b5", "#862e9c",
+		"#b197fc", "#9775fa", "#845ef7", "#7950f2", "#7048e8", "#6741d9", "#5f3dc4",
+		"#91a7ff", "#748ffc", "#5c7cfa", "#4c6ef5", "#4263eb", "#3b5bdb", "#364fc7",
+		"#74c0fc", "#4dabf7", "#339af0", "#228be6", "#1c7ed6", "#1971c2", "#1864ab",
+		"#66d9e8", "#3bc9db", "#22b8cf", "#15aabf", "#1098ad", "#0c8599", "#0b7285",
+		"#63e6be", "#38d9a9", "#20c997", "#12b886", "#0ca678", "#099268", "#087f5b",
+		"#8ce99a", "#69db7c", "#51cf66", "#40c057", "#37b24d", "#2f9e44", "#2b8a3e",
+		"#c0eb75", "#a9e34b", "#94d82d", "#82c91e", "#74b816", "#66a80f", "#5c940d",
+		"#ffe066", "#ffd43b", "#fcc419", "#fab005", "#f59f00", "#f08c00", "#e67700",
+		"#ffc078", "#ffa94d", "#ff922b", "#fd7e14", "#f76707", "#e8590c", "#d9480f"
 	],
  
 	availableBackgroundColors: [
@@ -544,7 +544,6 @@ Ext.define(&#39;amdaPlotObj.PlotObjectConfig&#39;, {
 			dimNullValue: "-1"
 		}
 	},
-
 	getParamConfig: function (paramId, onParamConfigLoaded) {
 		AmdaAction.getParamPlotInit({ "paramId": paramId }, function (result, e) {
 			onParamConfigLoaded(result.success, result.data);
@@ -17,6 +17,8 @@
 Ext.define('amdaPlotComp.PlotZoomPlug', {
   extend: 'Ext.util.Observable',
   alias: 'plugin.plotZoomPlugin',
+  requires: [
+    'amdaPlotComp.plotFunction.ParamField', 'amdaPlotComp.plotFunction.FunctionType'],
  
   id: 'plot-zoom-plug',
  
@@ -30,6 +32,14 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
   panelId: -1,
  
   linkedTTCatNode: null,
+  /**
+   * Un composant de 'PlotFunction' qui permet d'afficher le min samplig de chaque paramètre et le nombre de points théoriques entre un start time et stop time
+   */
+  plotFunctionParamField: null,
+  /**
+   * Un composant de 'PlotFunction' qui permet à l'utilisateur de séléctionner le type de fonction à appliquer : FFT, SUM, ...
+   */
+  plotFunctionType: null,
  
   constructor: function (config) {
     Ext.apply(this, config);
@@ -44,12 +54,25 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
     this.hostCmp = cmp;
   },
  
+  /**
+   * Set different parameters displayed on the current panel
+   * @param {*} listParams_  parameters displayed on the current panel
+   */
+  setParameters: function (listParams_) {
+    this.listParams = listParams_;
+    this.plotFunctionParamField = new amdaPlotComp.plotFunction.ParamField({ params: this.listParams });
+    this.plotFunctionType = new amdaPlotComp.plotFunction.FunctionType({});
+  },
+
+
   setMinValue: function (min) {
     if (!this.form)
       return;
  
-    if (this.zoomType == 'timeAxis')
+    if (this.zoomType == 'timeAxis') {
       this.form.getForm().findField('zoom-min-time').setValue(min);
+
+    }
     else
       this.form.getForm().findField('zoom-min-float').setValue(min);
   },
@@ -60,12 +83,18 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
  
     if (this.zoomType == 'timeAxis') {
       var minValue = this.form.getForm().findField('zoom-min-time').getValue();
-      if (minValue <= max)
+      if (minValue <= max) {
         this.form.getForm().findField('zoom-max-time').setValue(max);
+        if (this.isPlotFunction)
+          this.plotFunctionParamField.setValues(minValue, max);
+      }
       else {
         this.form.getForm().findField('zoom-min-time').setValue(max);
         this.form.getForm().findField('zoom-max-time').setValue(minValue);
+        if (this.isPlotFunction)
+          this.plotFunctionParamField.setValues(max, minValue);
       }
+
     }
     else {
       var minValue = this.form.getForm().findField('zoom-min-float').getValue();
@@ -101,7 +130,8 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
   /**
    *  creation of the window
    */
-  show: function (interactiveId, zoomType, panelId) {
+  show: function (interactiveId, zoomType, panelId, isPlotFunction_ = false) {
+    this.isPlotFunction = isPlotFunction_;
     if (!this.win) {
       this.win = new Ext.Window({
         id: 'plot-zoom-win-' + this.hostCmp.ownerCt.getId(), // Plot window ID
@@ -135,7 +165,6 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
  
       Ext.PluginManager.register(this);
     }
-
     this.interactiveId = interactiveId;
     this.updateWinByType(zoomType, panelId);
     this.win.show();
@@ -157,15 +186,20 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
  
     switch (zoomType) {
       case 'timeAxis':
-        this.win.setTitle('Zoom on time axis');
+        if (this.isPlotFunction) {
+          const title = "Appliquer une Transformation";
+          this.win.setTitle(title + '-Panel Id: ' + panelId);
+        } else {
+          this.win.setTitle('Zoom on time axis & Interval selection - Panel Id : ' + panelId);
+        }
         break;
-      case 'y-left' :
+      case 'y-left':
         this.win.setTitle('Zoom on Y Left axis - Panel Id : ' + panelId);
         break;
-      case 'y-right' :
+      case 'y-right':
         this.win.setTitle('Zoom on Y Right axis - Panel Id : ' + panelId);
         break;
-      case 'xaxis_id' :
+      case 'xaxis_id':
         this.win.setTitle('Zoom on X axis - Panel Id : ' + panelId);
         break;
     }
@@ -193,18 +227,17 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
  
     this.hostCmp.panelImage.resetZoom();
   },
-  setTimePlot : function(){
+  setTimePlot: function () {
     var timeObj = new Object();
     timeObj.start = this.form.getForm().findField('zoom-min-time').getValue();
     timeObj.stop = this.form.getForm().findField('zoom-max-time').getValue();
     var plotModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.plot.id);
     plotModule.setTimeInterval(timeObj);
-    },
+  },
   /**
    *        Main form
    */
   getFormConfig: function () {
-
     var intervalFieldSet = {
       xtype: 'fieldset',
       title: 'Interval Selection',
@@ -218,7 +251,7 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
       items: [
         {
           xtype: 'datefield', name: 'zoom-min-time', fieldLabel: 'Start Time',
-          format: 'Y/m/d H:i:s.u', 
+          format: 'Y/m/d H:i:s.u',
         },
         {
           xtype: 'datefield', name: 'zoom-max-time', fieldLabel: 'Stop Time',
@@ -238,8 +271,8 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
           handler: function () {
             this.resetMinMaxValue();
           }
-        }, 
-         {
+        },
+        {
           xtype: 'button',
           width: 100,
           text: 'Use in Time Selection',
@@ -252,11 +285,11 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
     };
  
     var insertTypeStore = Ext.create('Ext.data.Store', {
-        fields: ['key', 'name'],
-        data : [
-          {"key":"timeTable", "name":"TimeTable"},
-          {"key":"catalog", "name":"Catalog"}
-        ]
+      fields: ['key', 'name'],
+      data: [
+        { "key": "timeTable", "name": "TimeTable" },
+        { "key": "catalog", "name": "Catalog" }
+      ]
     });
  
     var me = this;
@@ -287,30 +320,30 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
           fieldLabel: 'Name',
           name: 'ttcat-name',
           listeners:
-            {
-              render: function (o, op) {
-		var field = this;
-                var el = this.el;
-                var dropTarget = Ext.create('Ext.dd.DropTarget', el, {
-                  ddGroup: 'explorerTree',
-                  notifyOver: function (ddSource, e, data) {
-                    var TTCatType = me.form.getForm().findField('ttcat-type').getValue();
-                    if (data.records[0].data.leaf && (data.records[0].data.nodeType == TTCatType)) {
-			this.valid = true;
-			return this.dropAllowed;
-                    }
-                    this.valid = false;
-                    return this.dropNotAllowed;
-                  },
-                  notifyDrop: function (ddSource, e, data) {
-                    if (!this.valid)
-                      return false;
-                    field.setValue(data.records[0].get('text'));
-                    return true;
+          {
+            render: function (o, op) {
+              var field = this;
+              var el = this.el;
+              var dropTarget = Ext.create('Ext.dd.DropTarget', el, {
+                ddGroup: 'explorerTree',
+                notifyOver: function (ddSource, e, data) {
+                  var TTCatType = me.form.getForm().findField('ttcat-type').getValue();
+                  if (data.records[0].data.leaf && (data.records[0].data.nodeType == TTCatType)) {
+                    this.valid = true;
+                    return this.dropAllowed;
                   }
-                });
-              }
+                  this.valid = false;
+                  return this.dropNotAllowed;
+                },
+                notifyDrop: function (ddSource, e, data) {
+                  if (!this.valid)
+                    return false;
+                  field.setValue(data.records[0].get('text'));
+                  return true;
+                }
+              });
             }
+          }
         },
         {
           xtype: 'button',
@@ -347,31 +380,31 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
                   if (nodeWithSameName !== null)
                     me.linkedTTCatNode = nodeWithSameName;
                   else {
-		    module.createLinkedNode();
-		    module.getLinkedNode().set('text', TTCatName);
-		    me.linkedTTCatNode = module.getLinkedNode();
-		    var obj = {
-                        name: TTCatName,
-                        fromPlugin: true
+                    module.createLinkedNode();
+                    module.getLinkedNode().set('text', TTCatName);
+                    me.linkedTTCatNode = module.getLinkedNode();
+                    var obj = {
+                      name: TTCatName,
+                      fromPlugin: true
                     };
-		    if (isCatalog) {
-			Ext.Msg.prompt('Define Parameters', 'Please enter parameters number for the new catalog:', function(btn, text){
-				if (btn == 'ok'){
-					obj.nbParameters = parseInt(text,10);
-					if (isNaN(obj.nbParameters)) {
-						obj.nbParameters = 1;
-					}
-					module.createObject(obj);
-					me.linkedTTCatNode.editLeaf(function () {
-						me.insertInterval();
-					});
-				}
-			});
-			return;
-		    }
-		    else {
-			module.createObject(obj);
-		    }
+                    if (isCatalog) {
+                      Ext.Msg.prompt('Define Parameters', 'Please enter parameters number for the new catalog:', function (btn, text) {
+                        if (btn == 'ok') {
+                          obj.nbParameters = parseInt(text, 10);
+                          if (isNaN(obj.nbParameters)) {
+                            obj.nbParameters = 1;
+                          }
+                          module.createObject(obj);
+                          me.linkedTTCatNode.editLeaf(function () {
+                            me.insertInterval();
+                          });
+                        }
+                      });
+                      return;
+                    }
+                    else {
+                      module.createObject(obj);
+                    }
                   }
  
                   me.linkedTTCatNode.editLeaf(function () {
@@ -398,11 +431,13 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
       },
       items: [
         intervalFieldSet,
-        insertTTFieldSet
+        //Ici on rajoute les composants associés à la fonctionnalité 'PlotFunction'
+        me.isPlotFunction ? this.plotFunctionType : insertTTFieldSet,
+        me.isPlotFunction ? this.plotFunctionParamField : null,
       ],
       fbar: [
         {
-          text: 'Apply Zoom',
+          text: me.isPlotFunction ? "Apply" : 'Apply Zoom',
           width: 100,
           scope: this,
           handler: function () {
@@ -420,14 +455,33 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
               return;
             }
  
-            this.hostCmp.callInteractivePlot({
-              'action': 'zoom',
-              'interactiveId': this.interactiveId,
-              'panelId': this.panelId,
-              'axeId': this.zoomType,
-              'min': minZoom,
-              'max': maxZoom
-            });
+            if (me.isPlotFunction) {
+              const start_time = this.form.getForm().findField('zoom-min-time').getValue();
+              const stop_time = this.form.getForm().findField('zoom-max-time').getValue();
+
+              let request_to_send = {};
+              request_to_send = Object.assign({}, me.plotFunctionType.getValues(), me.plotFunctionParamField.getValues());
+              request_to_send = Object.assign({}, request_to_send, {
+                'action': 'plotFunction',
+                'interactiveId': this.interactiveId,
+                'panelId': this.panelId,
+                'starttime': start_time,
+                'stoptime': stop_time
+              });
+
+              this.hostCmp.callInteractivePlot(request_to_send);
+
+            } else {
+              this.hostCmp.callInteractivePlot({
+                'action': 'zoom',
+                'interactiveId': this.interactiveId,
+                'panelId': this.panelId,
+                'axeId': this.zoomType,
+                'min': minZoom,
+                'max': maxZoom
+              });
+            }
+
             this.hostCmp.panelImage.resetZoom();
           }
         },
@@ -447,6 +501,10 @@ Ext.define(&#39;amdaPlotComp.PlotZoomPlug&#39;, {
         }
       ]
     });
+
+    this.plotFunctionType.setParent(this.form.getForm());
+    this.plotFunctionParamField.setParent(this.form.getForm());
     return this.form;
-  }
+  },
+
 });
@@ -0,0 +1,201 @@
+/**
+ * Un composant de 'PlotFunction' qui permet à l'utilisateur de séléctionner le type de fonction à appliquer : FFT, SUM, ...
+ */
+Ext.define('amdaPlotComp.plotFunction.FunctionType', {
+    extend: 'Ext.form.Panel',
+    /**
+     * Le parent composant qui hébérge celui-ci
+     */
+    parent: null,
+    plotFunctionItems: {
+        type: {
+            name: "type",
+            field: "Function Type",
+            values: {
+                fft: "FFT",
+                sum: "AVG"
+            }
+        },
+        scale: {
+            name: "scale_abscisse",
+            field: "Scale Abscisse",
+            values: {
+                log: "Log",
+                linear: "Linear"
+            }
+        },
+        abscisse: {
+            name: "abscisse",
+            field: "Abscisse",
+            values: {
+                frequency: "Frequency",
+                period: "Period"
+            }
+        },
+        scale_ordonnee: {
+            name: "scale_ordonnee",
+            field: "Scale Ordonnée"
+        }
+    },
+
+    initComponent: function () {
+        const key_ = "key";
+        const name_ = "name";
+
+        //Combobox to choose the type of fucntion to be applied
+        const data_function_type = [];
+        let item_type = {};
+        item_type[key_] = this.plotFunctionItems.type.values.fft;
+        item_type[name_] = this.plotFunctionItems.type.values.fft;
+        data_function_type.push(item_type);
+        item_type = {};
+        item_type[key_] = this.plotFunctionItems.type.values.sum;
+        item_type[name_] = this.plotFunctionItems.type.values.sum;
+        data_function_type.push(item_type);
+
+        const function_type = Ext.create('Ext.data.Store', {
+            fields: [key_, name_],
+            data: data_function_type
+        });
+
+        //Combo to choose type of scaling
+        const data_ = [];
+        const item_log = {};
+        item_log[key_] = this.plotFunctionItems.scale.values.log;
+        item_log[name_] = this.plotFunctionItems.scale.values.log;
+        //data_.push(item_log);
+
+        const item_linear = {};
+        item_linear[key_] = this.plotFunctionItems.scale.values.linear;
+        item_linear[name_] = this.plotFunctionItems.scale.values.linear;
+        data_.push(item_linear);
+
+        const scale = Ext.create('Ext.data.Store', {
+            fields: [key_, name_],
+            data: data_
+        });
+
+        //Combo to choose x type data of FFT 
+        const data__ = [];
+        const item_frequency = {};
+        item_frequency[key_] = this.plotFunctionItems.abscisse.values.frequency;
+        item_frequency[name_] = this.plotFunctionItems.abscisse.values.frequency;
+        data__.push(item_frequency);
+
+        const item_period = {};
+        item_period[key_] = this.plotFunctionItems.abscisse.values.period;
+        item_period[name_] = this.plotFunctionItems.abscisse.values.period;
+        data__.push(item_period);
+
+        const abscisse = Ext.create('Ext.data.Store', {
+            fields: [key_, name_],
+            data: data__
+        });
+
+        const me = this;
+
+        const tabParams = Ext.create('Ext.form.FieldSet', {
+            collapsible: false,
+            layout: {
+                type: 'vbox',
+                pack: 'start',
+                align: 'stretch',
+            },
+            bodyStyle: 'background: none',
+            items: [
+                {
+                    xtype: 'combo',
+                    fieldLabel: this.plotFunctionItems.type.field,
+                    store: function_type,
+                    queryMode: 'local',
+                    displayField: name_,
+                    valueField: key_,
+                    editable: false,
+                    value: this.plotFunctionItems.type.values.sum,
+                    name: this.plotFunctionItems.type.name,
+                    listeners: {
+                        change: function (combo, value) {
+                            if (value === me.plotFunctionItems.type.values.sum) {
+                                me.parent.findField(me.plotFunctionItems.abscisse.name).setVisible(false);
+                            }
+                            else {
+                                me.parent.findField(me.plotFunctionItems.abscisse.name).setVisible(true);
+                            }
+                        }
+                    }
+                },
+                {
+                    xtype: 'combo',
+                    fieldLabel: this.plotFunctionItems.scale.field,
+                    store: scale,
+                    queryMode: 'local',
+                    displayField: name_,
+                    valueField: key_,
+                    editable: false,
+                    value: this.plotFunctionItems.scale.values.linear,
+                    name: this.plotFunctionItems.scale.name
+                },
+                {
+                    xtype: 'combo',
+                    fieldLabel: this.plotFunctionItems.abscisse.field,
+                    store: abscisse,
+                    queryMode: 'local',
+                    displayField: name_,
+                    valueField: key_,
+                    editable: false,
+                    hidden: true,
+                    value: this.plotFunctionItems.abscisse.values.frequency,
+                    name: this.plotFunctionItems.abscisse.name
+                },
+                {
+                    xtype: 'combo',
+                    fieldLabel: this.plotFunctionItems.scale_ordonnee.field,
+                    store: scale,
+                    queryMode: 'local',
+                    displayField: name_,
+                    valueField: key_,
+                    editable: false,
+                    value: this.plotFunctionItems.scale.values.linear,
+                    name: this.plotFunctionItems.scale_ordonnee.name
+                }
+            ]
+        });
+
+        const config =
+        {
+            title: 'Function Type',
+            bodyStyle: { background: '#dfe8f6' },
+            items: [tabParams]
+        };
+
+        Ext.apply(this, config);
+        this.callParent(arguments);
+    },
+
+    /**
+     * Mettre à jour le parent
+     * @param {*} parent_ le parent qui va hébérger
+     */
+    setParent: function (parent_) {
+        this.parent = parent_;
+    },
+
+    /**
+     * Retournes les valeurs des comboboxes associées à ce composant
+     * @returns les valeurs des comboboxes se forme d'un dictionnaire
+     */
+    getValues: function () {
+        const value_scale = this.parent.findField(this.plotFunctionItems.scale.name).getValue();
+        const value_abscisse = this.parent.findField(this.plotFunctionItems.abscisse.name).getValue();
+        const value_scale_ordonnee = this.parent.findField(this.plotFunctionItems.scale_ordonnee.name).getValue();
+        const type_function = this.parent.findField(this.plotFunctionItems.type.name).getValue();
+
+        let out = {};
+        out[this.plotFunctionItems.type.name] = type_function;
+        out[this.plotFunctionItems.abscisse.name] = value_abscisse;
+        out[this.plotFunctionItems.scale.name] = value_scale;
+        out[this.plotFunctionItems.scale_ordonnee.name] = value_scale_ordonnee;
+
+        return out;
+    }
+});
 \ No newline at end of file
@@ -0,0 +1,124 @@
+/**
+ * Un composant de 'PlotFunction' qui permet d'afficher le min samplig de chaque paramètre et le nombre de points théoriques entre un start time et stop time
+ */
+Ext.define('amdaPlotComp.plotFunction.ParamField', {
+    extend: 'Ext.form.Panel',
+    /**
+     * id du composant de type numberfield qui hébérge le min sampling
+     */
+    label_number_field: "NUMBERFIELD",
+    /**
+     * id du composant de type numberfield qui hébérge le nombre de points
+     */
+    label_number_field1: "NUMBERFIELD1",
+    /**
+     * Le composant parent de celui-ci
+     */
+    parent: null,
+
+    initComponent: function () {
+        const items_params = [];
+        const minSampling = "Min Sampling (s)";
+        const minValue = 0;
+        const labelWitdh = 120;
+        const width = 30;
+
+        for (p in this.params) {
+            const param = this.params[p];
+            const fieldSet = {
+                xtype: 'fieldset',
+                name: 'FIELDSET' + param.id,
+                title: param.id,
+                collapsible: false,
+                layout: {
+                    type: 'vbox',
+                    align: 'stretch',
+                },
+                items: [
+                    {
+                        xtype: 'numberfield',
+                        name: this.label_number_field + param.id,
+                        labelWidth: labelWitdh,
+                        width: width,
+                        value: param.MinSampling,
+                        minValue: minValue,
+                        disabled: true,
+                        fieldLabel: minSampling
+                    },
+                    {
+                        xtype: 'numberfield',
+                        name: this.label_number_field1 + param.id,
+                        labelWidth: labelWitdh,
+                        width: width,
+                        value: 0,
+                        minValue: minValue,
+                        fieldLabel: "Nb Points"
+                    }
+                ]
+            };
+
+            items_params.push(fieldSet);
+        }
+
+        const tabParams = Ext.create('Ext.tab.Panel', {
+            layout: 'fit',
+            plain: true,
+            bodyStyle: 'background: none',
+            items: items_params
+        });
+
+        const config =
+        {
+            title: 'Parameters Sampling',
+            layout: 'fit',
+            bodyStyle: { background: '#dfe8f6' },
+            items: [tabParams]
+        };
+
+        Ext.apply(this, config);
+        //Les arguments sont les paramètres, chaque paramètre contient un id et un min Sampling
+        this.callParent(arguments);
+    },
+
+    /**
+     * Set parent
+     * @param {*} parent_ le parent qui contient ce composant
+     */
+    setParent: function (parent_) {
+        this.parent = parent_;
+    },
+
+    /**
+     * Retourne les valeurs d'id, min sampling et nb_points de tout les parametres passés comme argument 
+     * @returns id1@minSampling1@nb_points1@id2@minSampling2@nb_points2....
+     */
+    getValues: function () {
+        let list = "";
+        const delimeter = "@";
+        let i = 0;
+        for (p in this.params) {
+            let param = this.params[p];
+            const ui_item = this.parent.findField(this.label_number_field1 + param.id);
+            if (i > 0) list += delimeter;
+            if (ui_item !== undefined && ui_item !== null) {
+                list += param.id + delimeter + param.MinSampling + delimeter + ui_item.getValue();
+            }
+            i++;
+        }
+        return { "param_nb_points": list };
+    },
+
+    /**
+     * Mettre à jour le nb_points en fonction de la valeur de start time et stop time passés en paramètres
+     * @param {*} startTime le start time issu du ZoomPlugin
+     * @param {*} stopTime le stop time issu du ZoomPlugin
+     */
+    setValues: function (startTime, stopTime) {
+        for (p in this.params) {
+            let param = this.params[p];
+            const nb_points = (stopTime - startTime) / param.MinSampling;
+            const ui_item = this.parent.findField(this.label_number_field1 + param.id);
+            ui_item.setValue(parseInt(nb_points));
+        }
+    }
+});
 \ No newline at end of file
@@ -29,6 +29,7 @@ Ext.define(&#39;amdaUI.PlotTabResultUI&#39;, {
 	disableSynchronize: false,
 	multiplot: false,
 	plotName: '',
+	listParams: [],
  
 	hiddenForm: null,
  
@@ -77,6 +78,9 @@ Ext.define(&#39;amdaUI.PlotTabResultUI&#39;, {
  
 		var panelContext = amdaPlotComp.PlotContextManager.getPanelById(this.crtContext, panelId);
 		var size = this.getImageSize();
+		// We need a list of parameters to compute the number of points needed to apply FFT
+		this.listParams = panelContext["parameters"];
+		zoomPlugin.setParameters(this.listParams);
  
 		var me = this;
 		var insertIntervalItem = null;
@@ -153,6 +157,16 @@ Ext.define(&#39;amdaUI.PlotTabResultUI&#39;, {
 						},
 						scope: this
 					});
+					//plotFunction Menu
+					me.contextualMenu.add({
+						text: 'Appliquer une Transformation',
+						handler: function (item, e) {
+							zoomPlugin.show(me.interactiveId, axis.id, panelContext.id, true);
+							zoomPlugin.resetMinMaxValue();
+							me.panelImage.startZoom(true, 0, size.height, onMinTimeSelection, onMaxTimeSelection);
+						},
+						scope: this
+					});
 					insertIntervalItem = {
 						text: 'Insert Interval in TimeTable or Catalog',
 						handler: function (item, e) {
@@ -529,25 +543,25 @@ Ext.define(&#39;amdaUI.PlotTabResultUI&#39;, {
 					this.callInteractivePlot({ 'action': 'goto', 'interactiveId': this.interactiveId, 'ttFileIndex': ttFileIndex, 'intIndex': ttintervalIndex });
 				}
 			},
-            '-',
+				'-',
 			{
 				text: 'Use This Time Inteval',
 				scope: this,
-				handler: function(){
-                                                                                                    var timeObj = new Object();
-                                                                                                    var startTime = new Date(this.crtContext.page.startTime*1000);
-                                                                                                    timeObj.start  = Ext.Date.add(startTime, Ext.Date.MINUTE, startTime.getTimezoneOffset());
-                                                                                                    
-                                                                                                    var stopTime = new Date(this.crtContext.page.stopTime*1000);
-					timeObj.stop  = Ext.Date.add(stopTime, Ext.Date.MINUTE, stopTime.getTimezoneOffset());
+				handler: function () {
+					var timeObj = new Object();
+					var startTime = new Date(this.crtContext.page.startTime * 1000);
+					timeObj.start = Ext.Date.add(startTime, Ext.Date.MINUTE, startTime.getTimezoneOffset());
+
+					var stopTime = new Date(this.crtContext.page.stopTime * 1000);
+					timeObj.stop = Ext.Date.add(stopTime, Ext.Date.MINUTE, stopTime.getTimezoneOffset());
  
 					var plotModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.plot.id);
-                                                                                                    plotModule.setTimeInterval(timeObj);
+					plotModule.setTimeInterval(timeObj);
 				}
 			},
-			'-',
-			{		 
-				text: 'Go to Interval #',  
+				'-',
+			{
+				text: 'Go to Interval #',
 				scope: this,
 				handler: function (bt) {
 					var ttGotoNumberField = this.navToolBar.items.get('tt-goto-number-' + this.interactiveId);