Olsen V2.0 rewrote

/*
 * Original Author @author Tat
 * Mod code Vivienne Anthony
 * c++ rewrite vivienne (WIP)
 * verion 1.0 Functional Rewrite
 *
 * Changes
 *  Java to C++ conversion
 *  Memory pointer usage
 */

#include <iostream>
#include <vector>

#include <stdio.h>
#include <stdlib.h>
#include <png++/png.hpp>

using namespace std;

void SaveTerrFile(const int * image, int size, char * filename);

class OlsenNoise2D
{

public:
    OlsenNoise2D();
    void convolve(int * pixels, int offset, int stride, int x, int y, int width, int height, int matrix[], int matrixwidth, int matrixheight);
    void trim(int * pixels, int width, int height, int * workingpixels, int workingstride);
    int hashrandom(std::vector<long long int> elements);
    void olsennoise(int *  pixels, int stride, int x, int y, int width, int height);
    int getRequiredDim(int dim);
private:
    void olsennoise(int * pixels, int stride, int x_within_field, int y_within_field, int width, int height, int iteration) ;
    void applyNoise(int * pixels, int stride, int x_within_field, int y_within_field, int width, int height, int iteration);
    void applyScale(int * pixels, int stride, int width, int height, int factor);
    void applyShift(int * pixels, int stride, int shiftX, int shiftY, int width, int height);
    void applyColor(int * pixels, int stride, int width, int height);
    void applyBlur(int * pixels, int stride, int width, int height);
    int crimp(int color);
    int convolve(int * pixels, int stride, int index, int matrix[], int matrixwidth, int matrixheight);

    long long hash(long long v);

    /// constant statics
    static const int maxiterations=3;
    static const int blurEdge=2; //extra pixels are needed for the blur (3 - 1).
    static const int SCALE_FACTOR=2;


};

OlsenNoise2D::OlsenNoise2D()
{


}


void OlsenNoise2D::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);
}

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

void OlsenNoise2D::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);
}

void OlsenNoise2D::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*width);
            pixels[current] += (hashrandom( {j + x_within_field, k + y_within_field, iteration}) & (1 << (7 - iteration)));
        }
    }
}

void OlsenNoise2D::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];
        }
    }
}

void OlsenNoise2D::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];
        }
    }
}

void OlsenNoise2D::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;
        }
    }
}


void OlsenNoise2D::applyBlur(int * pixels, int stride, int width, int height)
{
    /// array
    int blur3x3[] = {1,1,1,1,1,1,1,1,1,1};

    convolve(pixels, 0, stride, 0, 0, width, height, blur3x3, 3, 3);
}

/**
    * 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.
    */

void OlsenNoise2D::convolve(int * pixels, int offset, int stride, int x, int y, int width, int height,int matrix[], int matrixwidth, int matrixheight)
{
    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, matrixwidth, matrixheight);
        }
    }
}

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

int OlsenNoise2D::convolve(int * pixels, int stride, int index, int matrix[], int matrixwidth, int matrixheight)
{
    int parts = 0;
    int sum = 0;
    int factor;

    for (int j = 0, m = matrixwidth; j < m; j++, index+=stride)
    {
        for (int k = 0, n = matrixheight; k < n; k++)
        {
            factor = matrix[j+(k*matrixwidth)];

            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
    */

int OlsenNoise2D::hashrandom(std::vector<long long int> elements)
{
    long long hashcalc = 0;


    for (int i = 0; i < elements.size(); i++)
    {
        hashcalc ^= elements[i];
        hashcalc = hash(hashcalc);
    }
    return (int) hashcalc;
};

long long OlsenNoise2D::hash(long long v)
{
    long long hash = v;
    long 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
 */
void OlsenNoise2D::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];
        }
    }
}


int main()
{

    /// Test
    int ImageSize=2049;
    int * imageInput = new int[ImageSize*ImageSize];

    /// Image
    OlsenNoise2D testingolsen;
    testingolsen.olsennoise(imageInput, 1, 0,0,ImageSize,ImageSize);

    SaveTerrFile(imageInput, ImageSize, "output.png");

    delete imageInput;



    return 1;
}


void SaveTerrFile(const int * image, int size, char * filename)
{
    png::image< png::rgb_pixel > newimage(size, size);

    for (unsigned int y = 0; y < newimage.get_width(); ++y)
    {
        for (unsigned int x = 0; x < newimage.get_height(); ++x)
        {
            int col = int(image[x+(y*newimage.get_width())]);
            newimage[y][x] = png::rgb_pixel(col,col,col);
            // non-checking equivalent of image.set_pixel(x, y, ...);
        }
    }

    newimage.write(filename);
}