numass-framework/numass-viewer/src/main/java/inr/numass/viewer/MspViewController.java

/* 
 * Copyright 2015 Alexander Nozik.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package inr.numass.viewer;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
import hep.dataforge.data.DataPoint;
import hep.dataforge.data.MapDataPoint;
import hep.dataforge.storage.api.PointLoader;
import hep.dataforge.storage.api.Storage;
import hep.dataforge.values.Value;
import static inr.numass.viewer.NumassViewerUtils.displayPlot;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import javafx.application.Platform;
import javafx.concurrent.Task;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.CheckBox;
import javafx.scene.layout.AnchorPane;
import javafx.scene.layout.VBox;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.LogAxis;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYStepRenderer;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.slf4j.LoggerFactory;

/**
 * FXML Controller class
 *
 * @author darksnake
 */
public class MspViewController implements Initializable {

    private FXTaskManager callback;

    @FXML
    private AnchorPane mspPlotPane;
    @FXML
    private VBox mspSelectorPane;

    /**
     * Initializes the controller class.
     *
     * @param url
     * @param rb
     */
    @Override
    public void initialize(URL url, ResourceBundle rb) {
        // TODO
    }

    /**
     * update detector pane with new data
     */
    private void updateMspPane(XYSeriesCollection detectorData) {
        Platform.runLater(() -> {
            if (detectorData == null) {
                throw new IllegalArgumentException("Detector data not defined");
            }

            mspSelectorPane.getChildren().clear();//removing all checkboxes
            mspPlotPane.getChildren().clear();//removing plot 

            DateAxis xAxis = new DateAxis("time");
            LogAxis yAxis = new LogAxis("partial pressure (mbar)");
            yAxis.setAutoRange(true);
            yAxis.setAutoTickUnitSelection(false);
            yAxis.setNumberFormatOverride(new DecimalFormat("0E0"));
            //NumberAxis yAxis = new NumberAxis();

            XYPlot plot = new XYPlot(detectorData, xAxis, yAxis, new XYStepRenderer());

            JFreeChart mspPlot = new JFreeChart("Mass-spectrum peak jump plot", plot);

            displayPlot(mspPlotPane, mspPlot);

            for (int i = 0; i < plot.getDatasetCount(); i++) {
                final XYDataset dataset = plot.getDataset(i);
                for (int j = 0; j < dataset.getSeriesCount(); j++) {
                    CheckBox cb = new CheckBox(dataset.getSeriesKey(j).toString());
                    cb.setSelected(true);
                    final int seriesNumber = j;
                    cb.setOnAction((ActionEvent event) -> {
                        boolean checked = cb.isSelected();
                        plot.getRendererForDataset(dataset).setSeriesVisible(seriesNumber, checked);
                    });
                    mspSelectorPane.getChildren().add(cb);
                }
            }
        });
    }

    public void fillMspData(Storage rootStorage) {
        if (rootStorage != null) {
            MspDataFillTask fillTask = new MspDataFillTask(rootStorage);
            if(callback!= null){
                callback.postTask(fillTask);
            }
            Viewer.runTask(fillTask);
        }
    }

    private class MspDataFillTask extends Task<Void> {
        
        private final Storage storage;

        public MspDataFillTask(Storage storage) {
            this.storage = storage;
        }
        
        @Override
        protected Void call() throws Exception {
            updateTitle("Fill msp data ("+storage.getName()+")");            
            MspDataLoadTask loadTask = new MspDataLoadTask(storage);
            if(callback!= null){
                callback.postTask(loadTask);
            }
            Viewer.runTask(loadTask);
            List<DataPoint> mspData = loadTask.get();
            Map<String, XYSeries> series = new HashMap<>();

            for (DataPoint point : mspData) {
                for (String name : point.names()) {
                    if (!name.equals("timestamp")) {
                        if (!series.containsKey(name)) {
                            series.put(name, new XYSeries(name));
                        }
                        long time = point.getValue("timestamp").timeValue().toEpochMilli();
                        double value = point.getDouble(name);
                        if (value > 0) {
                            series.get(name).add(time, value);
                        }
                    }
                }
            }
            XYSeriesCollection mspSeriesCollection = new XYSeriesCollection();
            List<String> names = new ArrayList<>(series.keySet());
            names.sort((String o1, String o2) -> {
                try {
                    return Integer.valueOf(o1).compareTo(Integer.valueOf(o2));
                } catch (Exception ex) {
                    return 0;
                }
            });
            for (String name : names) {
                mspSeriesCollection.addSeries(series.get(name));
            }
            updateMspPane(mspSeriesCollection);
            return null;
        }

    }

    private class MspDataLoadTask extends Task<List<DataPoint>> {

        private final Storage storage;

        public MspDataLoadTask(Storage storage) {
            this.storage = storage;
        }

        @Override
        protected List<DataPoint> call() throws Exception {
            updateTitle("Load msp data ("+storage.getName()+")");
            List<DataPoint> mspData = new ArrayList<>();
            DataPoint last = null;
            for (String loaderName : storage.loaders().keySet()) {
                if (loaderName.startsWith("msp")) {
                    try (PointLoader mspLoader = (PointLoader) storage.getLoader(loaderName)) {
                        mspLoader.open();
                        updateMessage("Loading mass spectrometer data from " + mspLoader.getName());
                        updateProgress(-1, 1);
                        for (DataPoint dp : mspLoader.asDataSet()) {
                            mspData.add(dp);
                            last = dp;
                        }
                        if (last != null) {
                            mspData.add(terminatorPoint(last));
                        }
                    } catch (Exception ex) {
                        LoggerFactory.getLogger(getClass()).error("Can't read msp loader data", ex);
                    }
                }
            }

            updateMessage("Loading msp data finished");
            updateProgress(0, 1);
            return mspData;
        }

    }

    public void setCallback(FXTaskManager callback) {
        this.callback = callback;
    }

    /**
     * Create a null value point to terminate msp series
     *
     * @param last
     * @return
     */
    private DataPoint terminatorPoint(DataPoint last) {
        MapDataPoint p = new MapDataPoint();
        p.putValue("timestamp", last.getValue("timestamp").timeValue().plusMillis(10));
        for (String name : last.namesAsArray()) {
            if (!name.equals("timestamp")) {
                p.putValue(name, Value.NULL);
            }
        }
        return p;
    }
}