BackgroundTask.java

package wf.util;

import javafx.concurrent.Task;
import javafx.scene.chart.XYChart;

public class BackgroundTask extends Task<Object> {

	private static DataHistoHandler dataHistoHandler = DataHistoHandler.getInstance();

    private static final BackgroundTask INSTANCE = new BackgroundTask();

    private int progressCounter;
    private int numberOfSeries;
    private int pointsOfSereis;

    private double sumYValue;
    private double bgValueAvg; //Average of the background t be subtracted

    public static BackgroundTask getInstance() {

		return INSTANCE;
	}

    @Override
    public Object call() throws Exception {

    	return null;
    }


    public Task<Void> subtractBackground(int points, int seriesTotalNumber) {
        return new Task<Void>() {
            @Override
            protected Void call() throws Exception {

            	progressCounter = 0;

            	for(int channel = 0; channel < 4; channel++) {

            		//System.out.println("Channel: " + channel);

            		if(dataHistoHandler.getSeriesValues().get(channel).size() > 0) {

            			// number of series per channel
            			numberOfSeries = dataHistoHandler.getSeriesValues().get(channel).size();

            			//loop through all the series of a channel
            			for(int series = 0; series < numberOfSeries; series++) {

            				//System.out.println("Series: " + series);

            				//loop through the series for background subtraction
            				pointsOfSereis = dataHistoHandler.getSeriesValues()
            						.get(channel).get(series).getData().size();

            				sumYValue = 0;

            				XYChart.Series<Number, Number> genericSeries = new XYChart.Series<>();
            				genericSeries.setName(String.valueOf(series));

            				for(int p = 0; p < pointsOfSereis; p++) {

            					if(p < points) {

            						//execute background subtraction accessing Y data
            						sumYValue = sumYValue + (double) dataHistoHandler.getSeriesValues()
                							.get(channel).get(series).getData()
                							.get(p).getYValue();

            						//System.out.println("Sum Y Value " + sumYValue);

            					} else {

            						//Compute background to be subtracted
            						bgValueAvg = sumYValue / (double) points;

            						//System.out.println("Sum Y Value " + sumYValue);
            						//System.out.println("Points " + points);
            						//System.out.println("Background " + bgValueAvg);
            						//Copy raw Series into Processed Series corrected for background

            						dataHistoHandler.getSeriesValuesProc().get(channel)
        		    				.add(genericSeries);

            						//populating the series with data
            		    			for(int i = 0; i < pointsOfSereis; i++) {

            		    				dataHistoHandler.getSeriesValuesProc().get(channel)
            		    				.get(series).getData()
            		    				.add(new XYChart.Data<Number, Number>(i, (double) dataHistoHandler
            		    						.getSeriesValues().get(channel).get(series)
            		    						.getData().get(i).getYValue() - bgValueAvg));
            		    			}

            		    			DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_bg(round(bgValueAvg,3));


            		    			update(++progressCounter, seriesTotalNumber);
            		    			//this.updateProgress(progressCounter++, seriesTotalNumber);
            		    			//Progress is related to the channels processed

            	            		//System.out.println(progressCounter);
            	            		//System.out.println(seriesTotalNumber);

            						break;
            					}
            				}
            			}
            		}

            		//Progress is related to the channels processed
            		//this.updateProgress(channel+1, 4);
            	}

                return null;
            }
        };
    }

    private double round(double value, int places) {
	    if (places < 0) throw new IllegalArgumentException();

	    long factor = (long) Math.pow(10, places);
	    value = value * factor;
	    long tmp = Math.round(value);
	    return (double) tmp / factor;
	}

    private void update(int value1, int value2) {

    	this.updateProgress(value1, value2);

    	//System.out.println("Value " + value);
    }



}