import "github.com/KEINOS/go-noise"

const seed = 100       // noise pattern ID
const smoothness = 100 // noise smoothness

// noiseType choises
//   noise.Perlin
//   noise.OpenSimplex
//   noise.Custom
n, err := noise.New(noise.Perlin, seed)

yy := n.Eval64(x / smoothness) // yy is between -1.0 and 1.0 of float64
y := (yy + 1) / 2 * 500        // y is between 0 and 500

// Obtain the noise value at the position (x, y)
n, err := noise.New(noiseType, seed)
v := n.Eval64(x, y) // v is between -1.0 and 1.0 of float64

// Obtain the noise value at the position (x, y, z)
n, err := noise.New(noise.Perlin, seed)
v := n.Eval64(x, y, z) // v is between -1.0 and 1.0 of float64

// Obtain the noise value at the position (x, y, z)
n, err := noise.New(noise.OpenSimplex, seed)
v := n.Eval64(x, y, z) // v is between -1.0 and 1.0 of float64

go get "github.com/KEINOS/go-noise"

// import "github.com/KEINOS/go-noise"

noise.New(noiseType noise.Algo, seed int64) (noise.Generator, error)

const seed = 100

// Noise generator for Perlin noise
genNoise, err := noise.New(noise.Perlin, seed)

const seed = 100

// Noise generator for OpenSimplex noise
genNoise, err := noise.New(noise.OpenSimplex, seed)

const seed = 100

// Noise generator for Custom noise
genNoise, err := noise.New(noise.Custom, seed)

// User defined noise generator
myNoise32 := func(seed int64, dim ...float32) float32 {
    // ...
}

// Assign generator for float32 type
genNoise, err := genNoise.SetEval32(myNoise32)

a := genNoise.Eval32(x)       // 1D noise. Obtain noise value at x.
b := genNoise.Eval32(x, y)    // 2D noise. Obtain noise value at x, y.
c := genNoise.Eval32(x, y, z) // 3D noise. Obtain noise value at x, y, z.

// a, b, c, x, y, z are float32.
// Noises a, b, c are between -1.0 and 1.0.

a := genNoise.Eval64(x)       // 1D noise. Obtain noise value at x.
b := genNoise.Eval64(x, y)    // 2D noise. Obtain noise value at x, y.
c := genNoise.Eval64(x, y, z) // 3D noise. Obtain noise value at x, y, z.

// a, b, c, x, y, z are float64.
// Noises a, b, c are between -1.0 and 1.0.

import "github.com/KEINOS/go-noise"

const seed = 100
const frame = 50

// Create new noise generator of Perlin type
genNoise, err := noise.New(noise.Perlin, seed)

if err != nil {
    // error handle
}

for z := 0; z < frame; z++ {
    zz := float64(z) / 5 // smoothness between frames

    /* Here create a new image of a frame */

    for y := 0; y < height; y++ {
        yy := float64(y) / 25 // smoothness between plotting points

        for x := 0; x < width; x++ {
            xx := float64(x) / 25 // smoothness between plotting points

            // n is a float64 value between -1 and 1
            n := genNoise.Eval64(xx, yy, zz)

            // Convert n to 0-255 scale
            grayColor := ((1. - in) / 2.) * 255.

            pixelToPlot := color.Gray{Y: uint8(grayColor)}

            /* Here plot the pixel to the current image */
        }
    }

    /* Here save the current frame/image to a file */
}

/* Here animate the frames if you want */