Merge branch 'MAZ_11362' into amdadev

Benjamin Renard
2 parents e1b680c2 d7558ac5
Showing 5 changed files with 251 additions and 176 deletions Show diff stats
js/app/views/PlotComponents/PlotPreviewUI.js
js/app/views/PlotComponents/plotFunction/BaseComponent.js
js/app/views/PlotComponents/plotFunction/FFTCmpt.js
js/app/views/PlotComponents/plotFunction/FunctionType.js
js/app/views/PlotComponents/plotFunction/Histogram.js
@@ -24,6 +24,7 @@ Ext.define(&#39;amdaPlotComp.PlotPreviewUI&#39;, {
 	],
  
 	isPlotFunction: false,
+	disableDownloadingData:false,
 	panelImage: null,
 	crtContext: null,
 	sliderPage: null,
@@ -148,7 +149,7 @@ Ext.define(&#39;amdaPlotComp.PlotPreviewUI&#39;, {
  
 	updatePlotImage: function (configResult, newPlot) {
 		this.crtContext = configResult.context;
-		this.isPlotFunction = configResult.plotFile.includes("plotFunction");
+		this.isPlotFunction = configResult.plotFile.includes("plotFunction") || configResult.plotFile.includes("histoPlot");
 		this.interactiveId = configResult.interactiveId;
 		this.panelId = configResult.panelId;
 		this.folder = configResult.folder;
@@ -176,7 +177,9 @@ Ext.define(&#39;amdaPlotComp.PlotPreviewUI&#39;, {
 		this.time = new Date(configResult.time);
 		this.time = Ext.Date.add(this.time, Ext.Date.MINUTE, this.time.getTimezoneOffset());
 		this.panelId = configResult.panelId;
-		this.isPlotFunction = configResult.plotFile.includes("plotFunction");
+		//Solution temporaire
+		this.isPlotFunction = configResult.plotFile.includes("plotFunction") || configResult.plotFile.includes("histoPlot");
+		this.disableDownloadingData = configResult.plotFile.includes("histoPlot");
 		this.plotFile = configResult.plotFile;
  
 		this.coordinatesField = new Ext.toolbar.TextItem({
@@ -271,7 +274,7 @@ Ext.define(&#39;amdaPlotComp.PlotPreviewUI&#39;, {
 			dock: 'top',
 			items: [
 				this.gotoDateGroup,
-				this.downloadDataBtn,
+				me.disableDownloadingData ? null: this.downloadDataBtn,
 			]
 		}
 		var mouseToolbar = {
@@ -0,0 +1,13 @@
+// Define the base class
+Ext.define('amdaPlotComp.plotFunction.BaseComponent', {
+    extend: 'Ext.form.FieldSet',
+    
+    /**
+     * Subclasses are expected to implement this method to retrieve values.
+     * @returns {Object} The values.
+     * @throws {Error} If the method is not implemented.
+     */
+    getValues: function () {
+        throw new Error('getValues() method must be implemented by subclass');
+    }
+});
@@ -0,0 +1,45 @@
+Ext.define('amdaPlotComp.plotFunction.FFTCmpt', {
+    extend: 'amdaPlotComp.plotFunction.BaseComponent',
+    title: "FFT Arguments",
+    id: 'fftComboBox',
+  
+    initComponent: function () {
+        const me = this;
+
+        // Define combo box store
+        const comboStore = Ext.create('Ext.data.Store', {
+            fields: ['label', 'value'],
+            data: [
+                { label: 'Frequency', value: 'Frequency' },
+                { label: 'Period', value: 'Period' }
+            ]
+        });
+
+        // Create combo box
+        const fftCombo = Ext.create('Ext.form.field.ComboBox', {
+            itemId: me.id, // Add itemId here
+            fieldLabel: 'Abscisse',
+            store: comboStore,
+            queryMode: 'local',
+            displayField: 'label',
+            valueField: 'value',
+            editable: false,
+            value: 'Frequency'
+        });
+
+        // Assign items to the component
+        me.items = [fftCombo];
+
+        // Call the parent class's initComponent method
+        me.callParent(arguments);
+    },
+
+    getValues: function () {
+        const fftComboBox = this.down('#'+this.id); // Retrieve ComboBox by itemId
+        const selectedValue = fftComboBox.getValue(); // Get selected value
+
+        return {
+            abscisse: selectedValue
+        };
+    }
+});
@@ -3,120 +3,98 @@
  */
 Ext.define('amdaPlotComp.plotFunction.FunctionType', {
     extend: 'Ext.form.Panel',
-    
-    plotFunctionItems: {
-        type: {
-            name: "type",
-            field: "Function Type",
-            values: {
-                fft: "FFT",
-                dft: "DFT",
-                sum: "SUM",
-                avg: "AVG"
-            },
-            labels: {
-                fft: "FFT (Magnitude^2)",
-                dft: "DFT (Magnitude^2)",
-                sum: "SUM",
-                avg: "AVG"
-            }
-        },
-        scale: {
-            name: "scale_abscisse",
-            field: "X-Axis Scale",
-            values: {
-                log: "logarithmic",
-                linear: "linear",
-                inherits: "Inherits"
-            }
-        },
-        abscisse: {
-            name: "abscisse",
-            field: "Abscisse",
-            values: {
-                frequency: "Frequency",
-                period: "Period"
-            }
-        },
-        scale_ordonnee: {
-            name: "scale_ordonnee",
-            field: "Y-Axis Scale"
-        }
+
+    view: null,
+    currentModule: null,
+
+    functionComboBox: "type",
+    x_axis: { label: "X Axis", value: "scale_abscisse" },
+    y_axis: { label: "Y Axis", value: "scale_ordonnee" },
+    scaleOptions: {
+        linear: { label: "Linear", value: "linear" },
+        logarithmic: { label: "Logarithmic", value: "logarithmic" }
+    },
+    functionOptions: {
+        fft: { label: "FFT (Magnitude^2)", value: "FFT" },
+        dft: { label: "DFT (Magnitude^2)", value: "DFT" },
+        sum: { label: "SUM", value: "SUM" },
+        avg: { label: "AVG", value: "AVG" },
+        hist: { label: "Histogram Plot 1D", value: 'histoPlot' }
     },
  
-    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.labels.fft;
-        data_function_type.push(item_type);
-        item_type = {};
-        item_type[key_] = this.plotFunctionItems.type.values.dft;
-        item_type[name_] = this.plotFunctionItems.type.labels.dft;
-        // Disbale DFT momentarily
-        data_function_type.push(item_type);
-
-        item_type = {};
-        item_type[key_] = this.plotFunctionItems.type.values.sum;
-        item_type[name_] = this.plotFunctionItems.type.labels.sum;
-        data_function_type.push(item_type);
-        item_type = {};
-        item_type[key_] = this.plotFunctionItems.type.values.avg;
-        item_type[name_] = this.plotFunctionItems.type.labels.avg;
-        data_function_type.push(item_type);
-
-        const function_type = Ext.create('Ext.data.Store', {
-            fields: [key_, name_],
-            data: data_function_type
+    createFunctionComboBox: function (defaultSelection) {
+        const self = this;
+        const comboStore = Ext.create('Ext.data.Store', {
+            fields: ['label', 'value'],
+            data: Object.values(this.functionOptions)
         });
  
-        //Combo to choose type of scaling
-        const data_ = [];
-        const item_inherits = {};
-        item_inherits[key_] = this.plotFunctionItems.scale.values.inherits;
-        item_inherits[name_] = this.plotFunctionItems.scale.values.inherits;
-        // Disbale inherits momentarily
-        //data_.push(item_inherits);
-
-        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_
+        const combo = Ext.create('Ext.form.field.ComboBox', {
+            fieldLabel: 'Function',
+            store: comboStore,
+            queryMode: 'local',
+            displayField: 'label',
+            valueField: 'value',
+            editable: false,
+            name: this.functionComboBox,
+            value: defaultSelection || Object.values(this.functionOptions)[2].value, // Default value
+            listeners: {
+                change: function (combo, value) {
+                    self.handleFunction(value);
+                }
+            }
+        });
+
+        return combo;
+    },
+
+    createAxisComboBox: function (axis) {
+        const comboStore = Ext.create('Ext.data.Store', {
+            fields: ['label', 'value'],
+            data: Object.values(this.scaleOptions)
         });
  
-        //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 combo = Ext.create('Ext.form.field.ComboBox', {
+            fieldLabel: axis.label,
+            store: comboStore,
+            queryMode: 'local',
+            displayField: 'label',
+            valueField: 'value',
+            editable: false,
+            name: axis.value,
+            value: Object.values(this.scaleOptions)[0].value // Default value
         });
  
-        const me = this;
+        return combo;
+    },
+
+
+    handleFunction: function (value) {
+        if (this.currentModule) {
+            this.view.remove(this.currentModule, true);
+            this.currentModule = null;
+        }
+
+        switch (value) {
+            case this.functionOptions.fft.value:
+                this.currentModule = Ext.create('amdaPlotComp.plotFunction.FFTCmpt');
+                break;
+            case this.functionOptions.dft.value:
+                this.currentModule = Ext.create('amdaPlotComp.plotFunction.FFTCmpt', { title: "DFT Arguments" });
+                break;
+            case this.functionOptions.hist.value:
+                this.currentModule = Ext.create('amdaPlotComp.plotFunction.Histogram');
+                break;
+            default:
+                break;
+        }
+        if (this.currentModule)
+            this.view.add(this.currentModule);
+    },
+
  
-        var tabParams = Ext.create('Ext.form.FieldSet', {
+    initComponent: function () {
+        this.view = Ext.create('Ext.form.FieldSet', {
             collapsible: false,
             layout: {
                 type: 'vbox',
@@ -124,70 +102,14 @@ Ext.define(&#39;amdaPlotComp.plotFunction.FunctionType&#39;, {
                 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.fft || value === me.plotFunctionItems.type.values.dft) {
-                                me.getForm().findField(me.plotFunctionItems.abscisse.name).setVisible(true);
-                            }
-                            else {
-                                me.getForm().findField(me.plotFunctionItems.abscisse.name).setVisible(false);
-                            }
-                        }
-                    }
-                },
-                {
-                    xtype: 'combo',
-                    fieldLabel: this.plotFunctionItems.scale.field,
-                    store: scale,
-                    queryMode: 'local',
-                    displayField: name_,
-                    valueField: key_,
-                    editable: false,
-                    value: this.plotFunctionItems.scale.values.log,
-                    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.log,
-                    name: this.plotFunctionItems.scale_ordonnee.name
-                }
-            ]
+            items: [this.createFunctionComboBox(), this.createAxisComboBox(this.x_axis), this.createAxisComboBox(this.y_axis)]
         });
  
         const config =
         {
-            title: 'Function Type',
+            title: 'Function To Apply',
             bodyStyle: { background: '#dfe8f6' },
-            items: [tabParams]
+            items: [this.view]
         };
  
         Ext.apply(this, config);
@@ -199,17 +121,21 @@ Ext.define(&#39;amdaPlotComp.plotFunction.FunctionType&#39;, {
      * @returns les valeurs des comboboxes se forme d'un dictionnaire
      */
     getValues: function () {
-        const value_scale = this.getForm().findField(this.plotFunctionItems.scale.name).getValue();
-        const value_abscisse = this.getForm().findField(this.plotFunctionItems.abscisse.name).getValue();
-        const value_scale_ordonnee = this.getForm().findField(this.plotFunctionItems.scale_ordonnee.name).getValue();
-        const type_function = this.getForm().findField(this.plotFunctionItems.type.name).getValue();
-
+        const xAxisScale = this.getForm().findField(this.x_axis.value).getValue();
+        const yAxisScale = this.getForm().findField(this.y_axis.value).getValue();
+        const functionType = this.getForm().findField(this.functionComboBox).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;
+        out[this.functionComboBox] = functionType;
+        out[this.x_axis.value] = xAxisScale;
+        out[this.y_axis.value] = yAxisScale;
+
  
+        if (this.currentModule) {
+            const values = this.currentModule.getValues();
+            // Adding values to out
+            Object.assign(out, values);
+        }
+        
         return out;
     }
 });
 \ No newline at end of file
@@ -0,0 +1,88 @@
+Ext.define('amdaPlotComp.plotFunction.Histogram', {
+    extend: 'amdaPlotComp.plotFunction.BaseComponent',
+    title: "Histogram Arguments",
+
+    functionId: 'histo1d-function',
+    binsId: 'histo1d-xbinnumber',
+    xMinId: "histo1d-xmin",
+    xMaxId: 'histo1d-xmax',
+
+    initComponent: function () {
+        const me = this;
+
+        const comboStore = Ext.create('Ext.data.Store', {
+            fields: ['label', 'value'],
+            data: [
+                { value: 'density', label: 'Density' },
+                { value: 'normdensity', label: 'Normalised Density' }
+            ]
+        });
+
+        const densityTypeCombo = Ext.create('Ext.form.field.ComboBox', {
+            fieldLabel: 'Density Type',
+            name: me.functionId,
+            store: comboStore,
+            queryMode: 'local',
+            displayField: 'label',
+            valueField: 'value',
+            editable: false,
+            value: 'density'
+        });
+
+        Ext.apply(me, {
+            items: [
+                {
+                    xtype: 'numberfield',
+                    fieldLabel: 'X Min',
+                    name: me.xMinId,
+                    allowDecimals: true,
+                    hideTrigger: true,
+                    keyNavEnabled: false,
+                },
+                {
+                    xtype: 'numberfield',
+                    fieldLabel: 'X Max',
+                    name: me.xMaxId,
+                    allowDecimals: true,
+                    hideTrigger: true,
+                    keyNavEnabled: false,
+                },
+                {
+                    xtype: 'numberfield',
+                    fieldLabel: 'Number of Bins',
+                    name: me.binsId,
+                    minValue: 1,
+                    value: 100,
+                    allowDecimals: false,
+                    keyNavEnabled: false,
+                },
+                densityTypeCombo
+            ]
+        });
+
+        me.callParent(arguments);
+    },
+
+    getValues: function () {
+        const densityTypeCombo = this.query('[name=' + this.functionId + ']')[0];
+        const densityTypeValue = densityTypeCombo.getValue();
+
+        const numBinsField = this.query('[name=' + this.binsId + ']')[0];
+        const numBinsValue = numBinsField.getValue();
+
+        const xMinField = this.query('[name=' + this.xMinId + ']')[0];
+        const xMinValue = xMinField.getValue();
+
+        const xMaxField = this.query('[name=' + this.xMaxId + ']')[0];
+        const xMaxValue = xMaxField.getValue();
+
+        let out = {};
+
+        out[this.functionId] = densityTypeValue;
+        out[this.binsId] = numBinsValue;
+        out[this.xMinId] = xMinValue;
+        out[this.xMaxId] = xMaxValue;
+
+        return out;
+    }
+});