SmoothingTask.java

package wf.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

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

public class SmoothingTask extends Task<Object> {

	private static DataHistoHandler dataHistoHandler = DataHistoHandler.getInstance();

    private static final SmoothingTask INSTANCE = new SmoothingTask();

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

    private double sumYValue;
    private double sumYValueWeighted;

    private final int sm_div1 = 3; // divider constant for 3 points smoothing
    private final int sm_div2 = 9; // divider constant for 5 points smoothing
    private final int sm_div3 = 27; // divider constant for 7 points smoothing

    private final List<Integer> sm_k2 = new ArrayList<Integer>(Arrays.asList(1,2,3,2,1));
    private final List<Integer> sm_k3 = new ArrayList<Integer>(Arrays.asList(1,3,6,7,6,3,1));

    private int sm_kIndex; //index used to loop through the coefficients

    public static SmoothingTask getInstance() {

		return INSTANCE;
	}

    @Override
    public Object call() throws Exception {

    	return null;
    }

    //points refers to the number of points in the smoothing window
    //if twoSteps is true it means that processed data has to be used for smoothing
    public Task<Void> performSmoothing(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++) {

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

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

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

            				if(points == 3) {

            					//the first and last point are set to zero
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(0, 0.0));



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

                					sumYValue = 0;
                    				sumYValueWeighted = 0;

                					//evaluate weighted point from raw data
                					for(int j = i-1; j < i+2; j++) {

                						sumYValue = sumYValue + (double)
                								dataHistoHandler
            		    						.getSeriesValues().get(channel).get(series)
            		    						.getData().get(j).getYValue();
                					}

                					sumYValueWeighted = sumYValue / (double) sm_div1;

                					dataHistoHandler.getSeriesValuesProc().get(channel)
        		    				.get(series).getData()
        		    				.add(new XYChart.Data<Number, Number>(i, sumYValueWeighted));
                				}

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-1, 0.0));

            				} //end if 3 points

            				if(points == 5) {

            					//the first and last two points are set to zero
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(0, 0.0));
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(1, 0.0));

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

                					sumYValue = 0;
                    				sumYValueWeighted = 0;
                    				sm_kIndex = 0;

                					//evaluate weighted point from raw data
                					for(int j = i-2; j < i+3; j++) {

                						sumYValue = sumYValue + (double)
                								dataHistoHandler
            		    						.getSeriesValues().get(channel).get(series)
            		    						.getData().get(j).getYValue()
            		    						* (double) sm_k2.get(sm_kIndex);

                						sm_kIndex++;
                					}

                					sumYValueWeighted = sumYValue / (double) sm_div2;

                					dataHistoHandler.getSeriesValuesProc().get(channel)
        		    				.get(series).getData()
        		    				.add(new XYChart.Data<Number, Number>(i, sumYValueWeighted));
                				}

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-2, 0.0));

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-1, 0.0));

            				} //end if 5 points

            				if(points == 7) {

            					//the first and last three points are set to zero
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(0, 0.0));
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(1, 0.0));
            					dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(2, 0.0));


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

                					sumYValue = 0;
                    				sumYValueWeighted = 0;
                    				sm_kIndex = 0;

                					//evaluate weighted point from raw data
                					for(int j = i-3; j < i+4; j++) {

                						sumYValue = sumYValue + (double)
                								dataHistoHandler
            		    						.getSeriesValues().get(channel).get(series)
            		    						.getData().get(j).getYValue()
            		    						* (double) sm_k3.get(sm_kIndex);

                						sm_kIndex++;
                					}

                					sumYValueWeighted = sumYValue / (double) sm_div3;

                					dataHistoHandler.getSeriesValuesProc().get(channel)
        		    				.get(series).getData()
        		    				.add(new XYChart.Data<Number, Number>(i, sumYValueWeighted));
                				}

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-3, 0.0));

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-2, 0.0));

                				dataHistoHandler.getSeriesValuesProc().get(channel)
    		    				.get(series).getData().add(new XYChart.Data<Number, Number>(pointsOfSereis-1, 0.0));


            				} //end if 5 points




            				update(++progressCounter, seriesTotalNumber);
            			}
            		}

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

                return null;
            }
        };
    }

    private void update(int value1, int value2) {

    	this.updateProgress(value1, value2);

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