CalculateTask.java

package wf.util;

import java.util.ArrayList;
//import java.util.HashMap;
import java.util.List;

import javafx.concurrent.Task;

public class CalculateTask extends Task<Object> {

	private static DataHistoHandler dataHistoHandler = DataHistoHandler.getInstance();
	//private static DataWaveformHandler dataWaveformHandler = DataWaveformHandler.getInstance();
	//private static SignalDetector signalDetector = SignalDetector.getInstance();

    private static final CalculateTask INSTANCE = new CalculateTask();

    //waveform parameters to be calculated
	private double wf_amp_par; // waveform amplitude
	private int wf_amp_index_par; // waveform position index of amplitude
	private double wf_amp_90p_par; //waveform 90% amplitude
	private double wf_amp_50p_par; //waveform 50% amplitude
	private double wf_amp_10p_par; //waveform 10% amplitude
	private double wf_slope_par; // waveform slope rising signal side
	private double wf_rt_par; // waveform risetime
	private double wf_ft_par; // waveform falltime
	private double wf_peak_time_par; // waveform peak time
	private double wf_peak_time_l90p_par; //waveform peak time 90% amplitude leading
	private double wf_peak_time_l50p_par; //waveform peak time 50% amplitude leading
	private double wf_peak_time_l10p_par; //waveform peak time 10% amplitude leading
	private double wf_peak_time_t90p_par; //waveform peak time 90% amplitude leading
	private double wf_peak_time_t50p_par; //waveform peak time 50% amplitude leading
	private double wf_peak_time_t10p_par; //waveform peak time 10% amplitude leading
	private double wf_tot_par; //waveform time over threshold
	private double wf_charge_par; //waveform integral charge
	private double charge_val_left; // left side of the maximum
	private double charge_val_right; //right side of the maximum
	private int wf_n_peaks_par; //waveform number of peaks
	private boolean wf_is_regular_par; //waveform containing two zeros (start and end

	private List<Double> tempValues = new ArrayList<Double>();
	private List<Integer> extremes = new ArrayList<Integer>();

	//private HashMap<String, List> resultsMap = new HashMap<String, List>();

    private int progressCounter;
    private int numberOfSeries;
    private int pointsOfSeries;

    private double tempVal0;
    private double tempVal1;
    private double tempVal2;

    // variables for peak finding procedure
    //private List<Double> filteredData = new ArrayList<Double>();
    //private List<Double> avgFilter = new ArrayList<Double>();
    //private List<Double> stdFilter = new ArrayList<Double>();
    //private List<Integer> signals = new ArrayList<Integer>();

    //Variables for Peak Detection
    boolean peak_found = false;
    boolean first_peak_found = false;
    double amp_min = 0.0;
    double amp_max = 0.0;
    double delta_amp = 0.0;
    double peak_time = 0.0;

    double t_sum = 0.0;
    double t_sq_sum = 0.0;
    double t_sq_diff = 0.0;

	double bg_min = 0.0;
    double bg_max = 0.0;
    double bg_delta = 0.0;

    public static CalculateTask 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> performCalculation(int lag, double threshold, int seriesTotalNumber) {
        return new Task<Void>() {
            @Override
            protected Void call() throws Exception {

            	progressCounter = 0;

            	for(int channel = 0; channel < 4; 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++) {

            				pointsOfSeries = dataHistoHandler.getSeriesValuesProc()
            						.get(channel).get(series).getData().size();

            				calculateAmplitude(channel, series, pointsOfSeries);
            				calculatePeakTime();
            				calculateAmp90p();
            				calculateAmp50p();
            				calculateAmp10p();
            				calculateTime90pAmpL(channel, series, wf_amp_90p_par, wf_amp_index_par);
            				calculateTime50pAmpL(channel, series, wf_amp_50p_par, wf_amp_index_par);
            				calculateTime10pAmpL(channel, series, wf_amp_10p_par, wf_amp_index_par);
            				calculateTime90pAmpT(channel, series, wf_amp_90p_par, wf_amp_index_par, pointsOfSeries);
            				calculateTime50pAmpT(channel, series, wf_amp_50p_par, wf_amp_index_par, pointsOfSeries);
            				calculateTime10pAmpT(channel, series, wf_amp_10p_par, wf_amp_index_par, pointsOfSeries);
            				calculateRiseTime();
            				calculateFallTime();
            				calculateTimeOverThreshold();
            				calculateSlope();
            				calculateCharge(channel, series, wf_amp_index_par, pointsOfSeries);
            				//calculatePeaks(channel, series, pointsOfSeries, lag, threshold);
            				peakFinder(channel, series, pointsOfSeries, lag, threshold);
            				//peakFinderAlgorithm(channel, series, pointsOfSeries, lag, threshold);

            				isRegularSignal();

            				//inject estimated parameters to the model
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_amp(wf_amp_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time(wf_peak_time_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_amp_90p(wf_amp_90p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_amp_50p(wf_amp_50p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_amp_10p(wf_amp_10p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_l90p(wf_peak_time_l90p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_l50p(wf_peak_time_l50p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_l10p( wf_peak_time_l10p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_t90p( wf_peak_time_t90p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_t50p( wf_peak_time_t50p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_peak_time_t10p( wf_peak_time_t10p_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_rt(wf_rt_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_ft(wf_ft_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_tot(wf_tot_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_slope(wf_slope_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_charge(wf_charge_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_n_peaks(wf_n_peaks_par);
            				DataWaveformHandler.getWaveforms().get(channel).get(series).set_wf_is_regular(wf_is_regular_par);


            				update(++progressCounter, seriesTotalNumber);
            			}
            		}

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

                return null;
            }
        };
    }

    private void calculateAmplitude(int seriesChannel, int seriesIndex, int seriesLength) {

    	wf_amp_par = 0; //starting value of amplitude

    	for(int i = 0; i < seriesLength; i++) {

    		if((double) dataHistoHandler.getSeriesValuesProc()
					.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue() > wf_amp_par) {

    			wf_amp_par = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

    			wf_amp_index_par = i;
    		}
    	}

    	//System.out.println("Channel       : " + seriesChannel);
    	//System.out.println("Series        : " + seriesIndex);
    	//System.out.println("Max Amplitude : " + wf_amp_par);
    	//System.out.println("Max Amplitude : " + round(wf_amp_par, 3));
    	//System.out.println("Max Amp. Pos. : " + wf_amp_index_par);

    	wf_amp_par = round(wf_amp_par, 3);

    	//System.out.println("Amplitude: " + wf_amp_par);
    }

    private void calculatePeakTime() {

    	wf_peak_time_par = 0;

    	wf_peak_time_par = wf_amp_index_par;

    	//System.out.println("Peak Time: " + wf_peak_time_par);
    }

    private void calculateAmp90p() {

    	wf_amp_90p_par = 0;
    	wf_amp_90p_par = wf_amp_par * 0.9;
    	wf_amp_90p_par = round(wf_amp_90p_par, 3);

    	//System.out.println("Amplitude 90%: " + wf_amp_90p_par);
    }

    private void calculateAmp50p() {

    	wf_amp_50p_par = 0;
    	wf_amp_50p_par = wf_amp_par * 0.5;
    	wf_amp_50p_par = round(wf_amp_50p_par, 3);

    	//System.out.println("Amplitude 50%: " + wf_amp_50p_par);
    }

    private void calculateAmp10p() {

    	wf_amp_10p_par = 0;
    	wf_amp_10p_par = wf_amp_par * 0.1;
    	wf_amp_10p_par = round(wf_amp_10p_par, 3);

    	//System.out.println("Amplitude 10%: " + wf_amp_10p_par);
    }

    //leading time 90% amplitude
    private void calculateTime90pAmpL(int seriesChannel, int seriesIndex, double ampValue, int ampIndex) {

    	wf_peak_time_l90p_par = 0;

    	for(int i = ampIndex; i > -1; i --) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_l90p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())
    					+ (i-1);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_l90p_par = round(wf_peak_time_l90p_par, 3);

    	//System.out.println("Leading Time 90% Amp: " + wf_peak_time_l90p_par);
    }

    private void calculateTime50pAmpL(int seriesChannel, int seriesIndex, double ampValue, int ampIndex) {

    	wf_peak_time_l50p_par = 0;

    	for(int i = ampIndex; i > -1; i --) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_l50p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())
    					+ (i-1);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_l50p_par = round(wf_peak_time_l50p_par, 3);

    	//System.out.println("Leading Time 50% Amp: " + wf_peak_time_l50p_par);
    }

    private void calculateTime10pAmpL(int seriesChannel, int seriesIndex, double ampValue, int ampIndex) {

    	wf_peak_time_l10p_par = 0;

    	for(int i = ampIndex; i > -1; i --) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_l10p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue())
    					+ (i-1);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_l10p_par = round(wf_peak_time_l10p_par, 3);

    	//System.out.println("Leading Time 10% Amp: " + wf_peak_time_l10p_par);
    }

    //trailing time 90% amplitude
    private void calculateTime90pAmpT(int seriesChannel, int seriesIndex, double ampValue, int ampIndex, int seriesLength) {

    	wf_peak_time_t90p_par = 0;

    	for(int i = 0; i < seriesLength; i ++) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_t90p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())
    					+ (i);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_t90p_par = round(wf_peak_time_t90p_par, 3);

    	//System.out.println("Trailing Time 90% Amp: " + wf_peak_time_t90p_par);
    }

    //trailing time 50% amplitude
    private void calculateTime50pAmpT(int seriesChannel, int seriesIndex, double ampValue, int ampIndex, int seriesLength) {

    	wf_peak_time_t50p_par = 0;

    	for(int i = 0; i < seriesLength; i ++) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_t50p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())
    					+ (i);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_t50p_par = round(wf_peak_time_t50p_par, 3);

    	//System.out.println("Trailing Time 50% Amp: " + wf_peak_time_t50p_par);
    }

    private void calculateTime10pAmpT(int seriesChannel, int seriesIndex, double ampValue, int ampIndex, int seriesLength) {

    	wf_peak_time_t10p_par = 0;

    	for(int i = 0; i < seriesLength; i ++) {

    		if((ampValue <= (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue())
    				&& ( ampValue >= (double) dataHistoHandler.getSeriesValuesProc()
    	    				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) {

    			//calculate interpolated point in time knowing that t(i) - t(i-1) = 1
    			wf_peak_time_t10p_par = ((ampValue - (double) dataHistoHandler.getSeriesValuesProc()
				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())) /
    					((double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    							- (double) dataHistoHandler.getSeriesValuesProc()
    							.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue())
    					+ (i);

    			break; //stop for loop as soon as the point is evaluated
    		}
    	}

    	wf_peak_time_t10p_par = round(wf_peak_time_t10p_par, 3);

    	//System.out.println("Trailing Time 10% Amp: " + wf_peak_time_t10p_par);
    }

    //Rise time
    private void calculateRiseTime() {

    	wf_rt_par = 0;

    	wf_rt_par = wf_peak_time_l90p_par - wf_peak_time_l10p_par;
    	wf_rt_par = round(wf_rt_par, 3);

    	//System.out.println("Rise Time: " + wf_rt_par);
    }

    //Fall time
    private void calculateFallTime() {

    	wf_ft_par = 0;

    	wf_ft_par = wf_peak_time_t10p_par - wf_peak_time_t90p_par;
    	wf_ft_par = round(wf_ft_par, 3);

    	//System.out.println("Fall Time: " + wf_ft_par);
    }

    //Time over Threshold
    private void calculateTimeOverThreshold() {

    	wf_tot_par = 0;

    	wf_tot_par = wf_peak_time_t50p_par - wf_peak_time_l50p_par;
    	wf_tot_par = round(wf_tot_par, 3);

    	//System.out.println("Time Over Threshold: " + wf_tot_par);
    }

    //Slope
    private void calculateSlope() {

    	wf_slope_par = 0;

    	wf_slope_par = (wf_amp_90p_par - wf_amp_10p_par) / (wf_peak_time_l90p_par - wf_peak_time_l10p_par);
    	wf_slope_par = round(wf_slope_par, 3);

    	//System.out.println("Slope: " + wf_slope_par);
    }

    //charge
    private void calculateCharge(int seriesChannel, int seriesIndex, int ampIndex, int seriesLength) {

    	wf_charge_par = 0;

    	charge_val_left = 0;
    	charge_val_right = 0;
    	//calculate the partial charge left side of peak
    	//calculate the partial charge right side of the peak
    	//sum the two contributions

    	//left side included maximum
    	for(int i = ampIndex; i > -1; i--) {

    		//till reaches a zero
    		if((double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue() >= 0) {

    			charge_val_left = charge_val_left +
    					(double) dataHistoHandler.getSeriesValuesProc()
    			.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    			/ 50; //at the moment constants but to be changed!
    			//* 100 / 50 / 1000; //at the moment constants but to be changed!
    			//100 ps // /50 -> Ohm /1000 -> signal is in mV;

    		} else {

    			break;
    		}
    	}

    	//right side excluded maximum
    	for(int i = ampIndex+1; i < seriesLength; i++) {

    		if((double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue() >= 0) {

    			charge_val_right = charge_val_right +
    					(double) dataHistoHandler.getSeriesValuesProc()
    			.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue()
    			/ 50; //at the moment constants but to be changed!
    			//* 100 / 50 / 1000; //at the moment constants but to be changed!
    			//100 ps // /50 -> Ohm /1000 -> signal is in mV;

    		} else {

    			break;
    		}
    	}

    	wf_charge_par = charge_val_left + charge_val_right;
    	wf_charge_par = round(wf_charge_par, 3);

    	//System.out.println("Charge: " + wf_charge_par);

    }


    /*
    //A lag of 5 will use the last 5 observations to smooth the data.
    //A threshold of 3.5 will signal if a datapoint is 3.5 standard deviations away from the moving mean.
    private void calculatePeaks(int seriesChannel, int seriesIndex, int sereisLength, int lag, double threshold ) {

    	wf_n_peaks_par = 0;
    	//perform algorithm
    	tempValues.clear();
    	resultsMap.clear();

    	//copy series data to temporary list for later calculations
    	for(int i = 0; i < sereisLength; i++) {

    		tempValues.add((double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue());
    	}

    	//parameters to be set by the user
    	//int lag = 7; //30;
        //double threshold = 0.01; //5;
        double influence = 0;

        resultsMap = signalDetector.analyzeDataForSignals(tempValues, lag, threshold, influence);

        //display signals(peaks) in data series
        for(int s = 0; s <  resultsMap.get("signals").size(); s++) {

        	//System.out.println(resultsMap.get("signals").get(s));

        	 wf_n_peaks_par =  wf_n_peaks_par + Math.abs((int) resultsMap.get("signals").get(s));
        }

    	System.out.println("Peaks: " + wf_n_peaks_par);
    } */

    private void peakFinder(int seriesChannel, int seriesIndex, int seriesLength, int lag, double threshold ) {

    	wf_n_peaks_par = 0;
    	//perform algorithm

    	amp_max = 0;
    	amp_min = 0;

    	//define max and min of background for temporary fixed 12 pts
    	bg_min = 0.0;
        bg_max = 0.0;
        bg_delta = 0.0;
        
        for (int i = 0; i < seriesLength; i++) {

        	if(i < lag) {
        	
        		tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

        		if(tempVal0  < bg_min) {

        			bg_min = tempVal0;
        		}

        		if(tempVal0 > bg_max) {

        			bg_max = tempVal0;
        		}
        	}
        }

        bg_delta = bg_max + Math.abs(bg_min);

        //System.out.println("Delta Bg: " + bg_delta);

    	peak_found = false;

    	extremes.clear();

    	tempValues.clear();
    	//resultsMap.clear();

    	for(int i = 2; i < seriesLength-2; i++) {
    		
    		//Execute loop until the first zero after peak time is found 
    		if(((double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue() <= 0)
    			&& (i > wf_peak_time_par)) {
    			
    			break;
    		
    		} else {
    		
    			tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    					.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

    			tempVal1 = (double) dataHistoHandler.getSeriesValuesProc()
    					.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue();

    			tempVal2 = (double) dataHistoHandler.getSeriesValuesProc()
    					.get(seriesChannel).get(seriesIndex).getData().get(i+2).getYValue();

    			if((tempVal1-tempVal0)*(tempVal2-tempVal1) <= 0) {

    				if(!peak_found) {

    					amp_max = tempVal1;

    					if(amp_max - amp_min >= bg_delta*threshold) {
    						//if(amp_max - amp_min >= threshold) {

    						// now you have the indices of the extremes in your list `extremes`
    						extremes.add(i+1);
    						peak_found = true;
    					}

    				} else {

    					amp_min = tempVal1;
    					peak_found = false;

    				}
    			}
    		}

    	}
    	wf_n_peaks_par =  extremes.size();

    	//System.out.println("*** Peaks: " + wf_n_peaks_par);
    	//for(int i = 0; i < extremes.size(); i++) {

    		//System.out.println("Position Peak " + i + ": " + extremes.get(i));
    	//}
    }

    /*
    private void peakFinderAlgorithm(int seriesChannel, int seriesIndex, int sereisLength, int lag, double threshold ) {

    	wf_n_peaks_par = 0;
    	filteredData.clear();
    	avgFilter.clear();
    	stdFilter.clear();
    	signals.clear();
    	//perform algorithm

    	//initialize arrays
    	for(int i = 0; i < sereisLength; i ++) {

    		filteredData.add(0.0);
    		avgFilter.add(0.0);
    		stdFilter.add(0.0);
    	}

    	//define max and min of background for temporary fixed 12 pts
    	bg_min = 0.0;
        bg_max = 0.0;

        for (int i = 0; i < 12; i++) {

        	tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

        	if(tempVal0  < bg_min) {

        		bg_min = tempVal0;
        	}

        	if(tempVal0 > bg_max) {

        		bg_max = tempVal0;
        	}

        }

        t_sum = 0.0;
        amp_min = 0.0;
        amp_max = 0.0;

        //initialize average
        for (int i = 0; i < lag; i++) {

        	tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

        	filteredData.set(i, tempVal0);
        	t_sum = t_sum + tempVal0;
        }

        avgFilter.set(lag-1, t_sum / (lag));

        System.out.println("Initial AVGFilter: " + avgFilter.get(lag-1));

        //initialize standard deviation
        t_sq_sum = 0.0;
        t_sq_diff = 0.0;

        for (int i = 0; i < lag; i++) {

        	tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

        	t_sq_diff = (tempVal0 - avgFilter.get(lag-1) * (tempVal0 - avgFilter.get(lag-1)));

        	t_sq_sum = t_sq_sum + t_sq_diff;
        }

        stdFilter.set(lag-1, Math.sqrt((t_sq_sum / (lag-1))));

        System.out.println("Initial STDFilter: " + stdFilter.get(lag-1));

        //loop through all the points
        for (int i = lag; i < sereisLength-lag; i++) {

        	tempVal0 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i).getYValue();

        	tempVal1 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i+1).getYValue();

        	tempVal2 = (double) dataHistoHandler.getSeriesValuesProc()
    				.get(seriesChannel).get(seriesIndex).getData().get(i-1).getYValue();

        	if ((Math.abs(tempVal0 - avgFilter.get(i-1)) > threshold*stdFilter.get(i-1))) {

        		filteredData.set(i, tempVal0);

        		if (tempVal0 > avgFilter.get(i-1)) {

        			if(tempVal0 > (bg_max - bg_min)) {

        				peak_found = true;
        				first_peak_found = true;
        				amp_max = tempVal0;

        				signals.add(1);

        				filteredData.set(i, tempVal0);

        				while (amp_max < tempVal1) {

        					filteredData.set(i, tempVal0);
        					amp_max = tempVal1;
        					//peak_time = (i-1)*((sm_pts-1));
        					i++;
        				}

        				peak_found = false;

        				delta_amp = amp_max - amp_min;

        				amp_min = amp_max;
        				amp_max = 0.0;

        			} else {

        				peak_found = false;
        				//signals[i] = 0;
        				filteredData.set(i, tempVal0);
        			}

        		} else {

        			peak_found = false;
        			//signals[i] = 0;
        			filteredData.set(i, tempVal0);
        		}

          } else {

        	  peak_found = false;
        	  //signals[i] = 0;
        	  filteredData.set(i, tempVal0);
          }


          if((first_peak_found) && (!peak_found)) {

        	  amp_min = tempVal2;
          }

          //Update average
          t_sum = 0.0;

          for (int k = i-lag ; k < i ; k++) {

        	  t_sum = t_sum + filteredData.get(k);
          }

          avgFilter.set(i, t_sum / (lag));

          //update standard deviation
          t_sq_sum = 0.0;
          t_sq_diff = 0.0;

          for (int k = i-lag ; k < i ; k++) {

        	  t_sq_diff = (filteredData.get(k)-avgFilter.get(k)*(filteredData.get(k)-avgFilter.get(k)));

        	  t_sq_sum = t_sq_sum + t_sq_diff;
          }

          stdFilter.set(i, Math.sqrt((t_sq_sum / (lag-1))));

        }

        wf_n_peaks_par = signals.size();

    	System.out.println("Peaks: " + wf_n_peaks_par);
    } */

    private void isRegularSignal() {

    	wf_is_regular_par = true;

    	if(wf_n_peaks_par > 1) {

    		wf_is_regular_par = false;
    	}
    }

    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);
    }
}