Examples with WlCoef boofcv.struct.wavelet.WlCoef used on opensource projects

Example 6 with WlCoef

use of boofcv.struct.wavelet.WlCoef in project BoofCV by lessthanoptimal.

the class ImplWaveletTransformBorder method horizontalInverse.

public static void horizontalInverse(BorderIndex1D border, WlBorderCoef<WlCoef_F32> desc, GrayF32 input, GrayF32 output) {
    float[] trends = new float[input.width];
    float[] details = new float[input.width];
    final int height = output.height;
    final int paddedWidth = output.width + output.width % 2;
    WlCoef inner = desc.getInnerCoefficients();
    // need to convolve coefficients that influence the ones being updated
    int lowerExtra = -Math.min(inner.offsetScaling, inner.offsetWavelet);
    int upperExtra = Math.max(inner.getScalingLength() + inner.offsetScaling, inner.getWaveletLength() + inner.offsetWavelet);
    lowerExtra += lowerExtra % 2;
    upperExtra += upperExtra % 2;
    int lowerBorder = (UtilWavelet.borderInverseLower(desc, border) + lowerExtra) / 2;
    int upperBorder = (UtilWavelet.borderInverseUpper(desc, border, output.width) + upperExtra) / 2;
    boolean isLarger = input.width >= output.width;
    // where updated wavelet values are stored
    int lowerCompute = lowerBorder * 2 - lowerExtra;
    int upperCompute = upperBorder * 2 - upperExtra;
    int[] indexes = new int[lowerBorder + upperBorder];
    for (int i = 0; i < lowerBorder; i++) indexes[i] = i * 2;
    for (int i = lowerBorder; i < indexes.length; i++) indexes[i] = paddedWidth - (indexes.length - i) * 2;
    border.setLength(output.width + output.width % 2);
    WlCoef_F32 coefficients;
    for (int y = 0; y < height; y++) {
        // initialize details and trends arrays
        for (int i = 0; i < indexes.length; i++) {
            int x = indexes[i];
            details[x] = 0;
            trends[x] = 0;
            x++;
            details[x] = 0;
            trends[x] = 0;
        }
        for (int i = 0; i < indexes.length; i++) {
            int x = indexes[i];
            float a = input.get(x / 2, y);
            float d = input.get(input.width / 2 + x / 2, y);
            if (x < lowerBorder) {
                coefficients = desc.getBorderCoefficients(x);
            } else if (x >= upperBorder) {
                coefficients = desc.getBorderCoefficients(x - paddedWidth);
            } else {
                coefficients = desc.getInnerCoefficients();
            }
            final int offsetA = coefficients.offsetScaling;
            final int offsetB = coefficients.offsetWavelet;
            final float[] alpha = coefficients.scaling;
            final float[] beta = coefficients.wavelet;
            // add the trend
            for (int j = 0; j < alpha.length; j++) {
                // if an odd image don't update the outer edge
                int xx = border.getIndex(x + offsetA + j);
                if (isLarger && xx >= output.width)
                    continue;
                trends[xx] += a * alpha[j];
            }
            // add the detail signal
            for (int j = 0; j < beta.length; j++) {
                int xx = border.getIndex(x + offsetB + j);
                if (isLarger && xx >= output.width)
                    continue;
                details[xx] += d * beta[j];
            }
        }
        int indexDst = output.startIndex + y * output.stride;
        for (int x = 0; x < lowerCompute; x++) {
            output.data[indexDst + x] = (trends[x] + details[x]);
        }
        for (int x = paddedWidth - upperCompute; x < output.width; x++) {
            output.data[indexDst + x] = (trends[x] + details[x]);
        }
    }
}

Example 7 with WlCoef

use of boofcv.struct.wavelet.WlCoef in project BoofCV by lessthanoptimal.

the class UtilWavelet method borderInverseUpper.

/**
 * Returns the upper border (offset from image edge) for an inverse wavelet transform.
 */
public static int borderInverseUpper(WlBorderCoef<?> desc, BorderIndex1D border, int dataLength) {
    WlCoef inner = desc.getInnerCoefficients();
    int borderSize = borderForwardUpper(inner, dataLength);
    borderSize += borderSize % 2;
    WlCoef uu = borderSize > 0 ? inner : null;
    WlCoef ul = uu;
    WlCoef ll = inner;
    int indexUL = 1998;
    if (desc.getUpperLength() > 0) {
        uu = desc.getBorderCoefficients(-2);
        indexUL = 2000 - desc.getUpperLength() * 2;
        ul = desc.getBorderCoefficients(2000 - indexUL);
    }
    if (desc.getLowerLength() > 0) {
        ll = desc.getBorderCoefficients(0);
    }
    border.setLength(2000);
    borderSize = checkInverseUpper(uu, 2000 - borderSize, border, borderSize);
    borderSize = checkInverseUpper(ul, indexUL, border, borderSize);
    borderSize = checkInverseUpper(ll, 0, border, borderSize);
    return borderSize;
}