All Downloads are FREE. Search and download functionalities are using the official Maven repository.

be.tarsos.dsp.wavelet.lift.LineWavelet Maven / Gradle / Ivy

There is a newer version: 2.4-1
Show newest version
package be.tarsos.dsp.wavelet.lift;

/**
 * 

* Line (with slope) wavelet *

* *

* The wavelet Lifting Scheme "LineWavelet" wavelet approximates the data set * using a LineWavelet with with slope (in contrast to the HaarWavelet wavelet * where a LineWavelet has zero slope is used to approximate the data). *

* *

* The predict stage of the LineWavelet wavelet "predicts" that an odd point * will lie midway between its two neighboring even points. That is, that the * odd point will lie on a LineWavelet between the two adjacent even points. The * difference between this "prediction" and the actual odd value replaces the * odd element. *

* *

* The update stage calculates the average of the odd and even element pairs, * although the method is indirect, since the predict phase has over written the * odd value. *

* *

* Copyright and Use

* *

* You may use this source code without limitation and without fee as long as * you include: *

*
This software was written and is copyrighted by Ian Kaplan, Bear * Products International, www.bearcave.com, 2001.
*

* This software is provided "as is", without any warrenty or claim as to its * usefulness. Anyone who uses this source code uses it at their own risk. Nor * is any support provided by Ian Kaplan and Bear Products International. *

* Please send any bug fixes or suggested source changes to: * *

 *      [email protected]
 * 
* * @author Ian Kaplan */ public class LineWavelet extends LiftingSchemeBaseWavelet { /** *

* Calculate an extra "even" value for the LineWavelet wavelet algorithm at * the end of the data series. Here we pretend that the last two values in * the data series are at the x-axis coordinates 0 and 1, respectively. We * then need to calculate the y-axis value at the x-axis coordinate 2. This * point lies on a LineWavelet running through the points at 0 and 1. *

*

* Given two points, x1, y1 and x2, * y2, where *

* *
	 *         x1 = 0
	 *         x2 = 1
	 * 
*

* calculate the point on the LineWavelet at x3, y3, * where *

* *
	 *         x3 = 2
	 * 
*

* The "two-point equation" for a LineWavelet given x1, * y1 and x2, y2 is *

* *
	 *      .          y2 - y1
	 *      (y - y1) = -------- (x - x1)
	 *      .          x2 - x1
	 * 
*

* Solving for y *

* *
	 *      .    y2 - y1
	 *      y = -------- (x - x1) + y1
	 *      .    x2 - x1
	 * 
*

* Since x1 = 0 and x2 = 1 *

* *
	 *      .    y2 - y1
	 *      y = -------- (x - 0) + y1
	 *      .    1 - 0
	 * 
*

* or *

* *
	 *      y = (y2 - y1)*x + y1
	 * 
*

* We're calculating the value at x3 = 2, so *

* *
	 *      y = 2*y2 - 2*y1 + y1
	 * 
*

* or *

* *
	 *      y = 2*y2 - y1
	 * 
*/ private float new_y(float y1, float y2) { float y = 2 * y2 - y1; return y; } /** *

* Predict phase of LineWavelet Lifting Scheme wavelet *

* *

* The predict step attempts to "predict" the value of an odd element from * the even elements. The difference between the prediction and the actual * element is stored as a wavelet coefficient. *

*

* The "predict" step takes place after the split step. The split step will * move the odd elements (bj) to the second half of the array, * leaving the even elements (ai) in the first half *

* *
	 *     a0, a1, a1, a3, b0, b1, b2, b2,
	 * 
*

* The predict step of the LineWavelet wavelet "predicts" that the odd * element will be on a LineWavelet between two even elements. *

* *
	 *     bj+1,i = bj,i - (aj,i + aj,i+1)/2
	 * 
*

* Note that when we get to the end of the data series the odd element is * the last element in the data series (remember, wavelet algorithms work on * data series with 2n elements). Here we "predict" that the odd * element will be on a LineWavelet that runs through the last two even * elements. This can be calculated by assuming that the last two even * elements are located at x-axis coordinates 0 and 1, respectively. The odd * element will be at 2. The new_y() function is called to do this * simple calculation. *

*/ protected void predict(float[] vec, int N, int direction) { int half = N >> 1; float predictVal; for (int i = 0; i < half; i++) { int j = i + half; if (i < half - 1) { predictVal = (vec[i] + vec[i + 1]) / 2; } else if (N == 2) { predictVal = vec[0]; } else { // calculate the last "odd" prediction predictVal = new_y(vec[i - 1], vec[i]); } if (direction == forward) { vec[j] = vec[j] - predictVal; } else if (direction == inverse) { vec[j] = vec[j] + predictVal; } else { System.out.println("predictline::predict: bad direction value"); } } } // predict /** *

* The predict phase works on the odd elements in the second half of the * array. The update phase works on the even elements in the first half of * the array. The update phase attempts to preserve the average. After the * update phase is completed the average of the even elements should be * approximately the same as the average of the input data set from the * previous iteration. The result of the update phase becomes the input for * the next iteration. *

*

* In a HaarWavelet wavelet the average that replaces the even element is * calculated as the average of the even element and its associated odd * element (e.g., its odd neighbor before the split). This is not possible * in the LineWavelet wavelet since the odd element has been replaced by the * difference between the odd element and the mid-point of its two even * neighbors. As a result, the odd element cannot be recovered. *

*

* The value that is added to the even element to preserve the average is * calculated by the equation shown below. This equation is given in Wim * Sweldens' journal articles and his tutorial (Building Your Own * Wavelets at Home) and in Ripples in Mathematics. A somewhat * more complete derivation of this equation is provided in Ripples in * Mathematics by A. Jensen and A. la Cour-Harbo, Springer, 2001. *

*

* The equation used to calculate the average is shown below for a given * iteratin i. Note that the predict phase has already completed, so * the odd values belong to iteration i+1. *

* *
	 *   eveni+1,j = eveni,j op (oddi+1,k-1 + oddi+1,k)/4
	 * 
*

* There is an edge problem here, when i = 0 and k = N/2 (e.g., there is no * k-1 element). We assume that the oddi+1,k-1 is the same as * oddk. So for the first element this becomes * *

	 *       (2 * oddk)/4
	 * 
*

* or *

* *
	 *       oddk/2
	 * 
*/ protected void update(float[] vec, int N, int direction) { int half = N >> 1; for (int i = 0; i < half; i++) { int j = i + half; float val; if (i == 0) { val = vec[j] / 2.0f; } else { val = (vec[j - 1] + vec[j]) / 4.0f; } if (direction == forward) { vec[i] = vec[i] + val; } else if (direction == inverse) { vec[i] = vec[i] - val; } else { System.out.println("update: bad direction value"); } } // for } } // LineWavelet




© 2015 - 2024 Weber Informatics LLC | Privacy Policy