Create a new version of paste:

public class OlsenNoise2D {

    private static final int[][] blur3x3 = new int[][]{
        {1, 1, 1},
        {1, 1, 1},
        {1, 1, 1}
    };
    private static final int blurEdge = 2; //extra pixels are needed for the blur (3 - 1).

    
    private static final int maxiterations = 7;
    
    //The hope is to get scale factor working for other scales. Works only for 2 currently.
    private static final int SCALE_FACTOR = 2;

    public void olsennoise(int[] pixels, int stride, int x, int y, int width, int height) {
        olsennoise(pixels, stride, x, y, width, height, maxiterations);
        applyColor(pixels, stride, width, height);
    }

    public int getRequiredDim(int dim) {
        return dim + blurEdge + SCALE_FACTOR;
    }

    private void olsennoise(int[] pixels, int stride, int x_within_field, int y_within_field, int width, int height, int iteration) {
        if (iteration == 0) {
            applyNoise(pixels, stride, x_within_field, y_within_field, width, height, iteration);
            return;
        }
        int x_remainder = x_within_field & 1;
        int y_remainder = y_within_field & 1; //Math.abs(y_within_field % SCALE_FACTOR)
        olsennoise(pixels, stride,
                ((x_within_field + x_remainder) / SCALE_FACTOR) - x_remainder,
                ((y_within_field + y_remainder) / SCALE_FACTOR) - y_remainder,
                ((width  + x_remainder) / SCALE_FACTOR) + blurEdge,
                ((height + y_remainder) / SCALE_FACTOR) + blurEdge, iteration - 1);
        applyScale(pixels, stride, width + 2, height + 2, SCALE_FACTOR);
        applyShift(pixels, stride, x_remainder, y_remainder, width + 2, height + 2);
        applyBlur(pixels, stride, width + 2, height + 2);
        applyNoise(pixels, stride, x_within_field, y_within_field, width, height, iteration);
    }

    private void applyNoise(int[] pixels, int stride, int x_within_field, int y_within_field, int width, int height, int iteration) {
        int index = 0;
        for (int k = 0, n = height - 1; k <= n; k++, index += stride) {
            for (int j = 0, m = width - 1; j <= m; j++) {
                int current = index + j;
                pixels[current] += (hashrandom(j + x_within_field, k + y_within_field, iteration) & (1 << (7 - iteration)));
            }
        }
    }

    private void applyScale(int[] pixels, int stride, int width, int height, int factor) {
        int index = (height - 1) * stride;
        for (int k = 0, n = height - 1; k <= n; n--, index -= stride) {
            for (int j = 0, m = width - 1; j <= m; m--) {
                int current = index + m;
                int lower = ((n / factor) * stride) + (m / factor);
                pixels[current] = pixels[lower];
            }
        }
    }

    private void applyShift(int[] pixels, int stride, int shiftX, int shiftY, int width, int height) {
        if ((shiftX == 0) && (shiftY == 0)) {
            return;
        }

        int index;
        int indexoffset = shiftX + (shiftY * stride);
        index = 0;
        for (int k = 0, n = height - 1; k <= n; k++, index += stride) {
            for (int j = 0, m = width - 1; j <= m; j++) {
                int current = index + j;
                pixels[current] = pixels[current + indexoffset];
            }
        }
    }
    
    private void applyColor(int[] pixels, int stride, int width, int height) {
        int index;
        index = 0;
        for (int k = 0, n = height - 1; k <= n; k++, index += stride) {
            for (int j = 0, m = width - 1; j <= m; j++) {
                int current = index + j;
                int pixel = pixels[current];
                pixels[current] = 0xFF000000 | pixel << 16 | pixel << 8 | pixel;
            }
        }
    }

    private void applyBlur(int[] pixels, int stride, int width, int height) {
        convolve(pixels, 0, stride, 0, 0, width, height, blur3x3);
    }

    /**
     * Memory Free In-Place Convolution.
     * Modified to simply add values. (Greyscale as such).
     * 
     * @param pixels pixels to be modified
     * @param offset offset within the pixel array to call zero.
     * @param stride width of the memory block to next Y.
     * @param x the start x value.
     * @param y the start y value.
     * @param width the width of blocks to be used for the convolution.
     * @param height the height of the convolution area.
     * @param matrix matrix of the convolution.
     */
    
    public static void convolve(int[] pixels, int offset, int stride, int x, int y, int width, int height, int[][] matrix) {
        int index = offset + x + (y*stride);
        for (int j = 0; j < height; j++, index += stride) {
            for (int k = 0; k < width; k++) {
                int pos = index + k;
                pixels[pos] = convolve(pixels,stride,pos, matrix);
            }
        }
    }

    private static int crimp(int color) {
        return (color >= 0xFF) ? 0xFF : (color < 0) ? 0 : color;
    }

    private static int convolve(int[] pixels, int stride, int index, int[][] matrix) {
        int parts = 0;
        int sum = 0;
        int factor;
        for (int j = 0, m = matrix.length; j < m; j++, index+=stride) {
            for (int k = 0, n = matrix[j].length; k < n; k++) {
                factor = matrix[j][k];
                parts += factor;
                sum += factor * pixels[index + k];
            }
        }
        if (parts == 0) return crimp(sum);
        return crimp(sum/parts);
    }

    
    /**
     * XOR hash the hashed values of each element, in elements
     * @param elements elements to be hashed and xor'ed together.
     * @return
     */
    public static int hashrandom(int... elements) {
        long hash = 0;
        for (int i = 0; i < elements.length; i++) {
            hash ^= elements[i];
            hash = hash(hash);
        }
        return (int) hash;
    }

    private static long hash(long v) {
        long hash = v;
        long h = hash;

        switch ((int) hash & 3) {
            case 3:
                hash += h;
                hash ^= hash << 32;
                hash ^= h << 36;
                hash += hash >> 22;
                break;
            case 2:
                hash += h;
                hash ^= hash << 22;
                hash += hash >> 34;
                break;
            case 1:
                hash += h;
                hash ^= hash << 20;
                hash += hash >> 2;
        }
        hash ^= hash << 6;
        hash += hash >> 10;
        hash ^= hash << 8;
        hash += hash >> 34;
        hash ^= hash << 50;
        hash += hash >> 12;
        return hash;
    }

    /**
     * Trim off the edge pixels
     * 
     * @param pixels destination array
     * @param width Width of the new image
     * @param height height of the new image
     * @param workingpixels source array
     * @param workingstride stride of source array
     */
    public static void trim(int[] pixels, int width, int height, int[] workingpixels, int workingstride) {
        for (int k = 0; k < height; k++) {
            for (int j = 0; j < width; j++) {
                int index = j + (k * width);
                int workingindex = j + (k * workingstride);
                pixels[index] = workingpixels[workingindex];
            }
        }
    }

}