# SPDX-License-Identifier: GPL-2.0-or-later

# Another Noise Tool - Noise and Effects
# Jimmy Hazevoet

import bpy
from mathutils.noise import (
    seed_set,
    noise,
    turbulence,
    turbulence_vector,
    fractal,
    hybrid_multi_fractal,
    multi_fractal,
    ridged_multi_fractal,
    hetero_terrain,
    random_unit_vector,
    variable_lacunarity,
    voronoi,
)
from math import (
    floor, sqrt,
    sin, cos, pi,
)

noise_basis_default = "BLENDER"
noise_basis = [
    ("BLENDER", "Blender", "Blender default noise", 0),
    ("PERLIN_ORIGINAL", "Perlin", "Perlin noise", 1),
    ("PERLIN_NEW", "New Perlin", "New Perlin noise", 2),
    ("VORONOI_F1", "Voronoi F1", "Voronoi F1", 3),
    ("VORONOI_F2", "Voronoi F2", "Voronoi F2", 4),
    ("VORONOI_F3", "Voronoi F3", "Voronoi F3", 5),
    ("VORONOI_F4", "Voronoi F4", "Voronoi F4", 6),
    ("VORONOI_F2F1", "Voronoi F2-F1", "Voronoi F2-F1", 7),
    ("VORONOI_CRACKLE", "Voronoi Crackle", "Voronoi Crackle", 8),
    ("CELLNOISE", "Cell Noise", "Cell noise", 9)
]

# ------------------------------------------------------------
# Height scale:


def Height_Scale(input, iscale, offset, invert):
    if invert != 0:
        return (1.0 - input) * iscale + offset
    else:
        return input * iscale + offset


# Functions for marble_noise and effects:

def Dist(x, y):
    return sqrt((x * x) + (y * y))


def sin_bias(a):
    return 0.5 + 0.5 * sin(a)


def cos_bias(a):
    return 0.5 + 0.5 * cos(a)


def tri_bias(a):
    b = 2 * pi
    a = 1 - 2 * abs(floor((a * (1 / b)) + 0.5) - (a * (1 / b)))
    return a


def saw_bias(a):
    b = 2 * pi
    n = int(a / b)
    a -= n * b
    if a < 0:
        a += b
    return a / b


def soft(a):
    return a


def sharp(a):
    return a**0.5


def sharper(a):
    return sharp(sharp(a))


def no_bias(a):
    return a


def shapes(x, y, z, shape=0):
    p = pi
    if shape == 1:
        # ring
        x = x * p
        y = y * p
        s = cos(x**2 + y**2) / (x**2 + y**2 + 0.5)
    elif shape == 2:
        # swirl
        x = x * p
        y = y * p
        s = ((x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5))
    elif shape == 3:
        # bumps
        x = x * p
        y = y * p
        z = z * p
        s = 1 - ((cos(x * p) + cos(y * p) + cos(z * p)) - 0.5)
    elif shape == 4:
        # wave
        x = x * p * 2
        y = y * p * 2
        s = sin(x + sin(y))
    elif shape == 5:
        # z grad.
        s = (z * p)
    elif shape == 6:
        # y grad.
        s = (y * p)
    elif shape == 7:
        # x grad.
        s = (x * p)
    else:
        # marble default
        s = ((x + y + z) * 5)
    return s


# marble_noise
def marble_noise(x, y, z, origin, size, shape, bias, sharpnes, turb, depth, hard, basis, amp, freq):

    s = shapes(x, y, z, shape)
    x += origin[0]
    y += origin[1]
    z += origin[2]
    value = s + turb * turbulence_vector((x, y, z), depth, hard, noise_basis=basis)[1]

    if bias == 1:
        value = cos_bias(value)
    elif bias == 2:
        value = tri_bias(value)
    elif bias == 3:
        value = saw_bias(value)
    else:
        value = sin_bias(value)

    if sharpnes == 1:
        value = 1.0 - sharp(value)
    elif sharpnes == 2:
        value = 1.0 - sharper(value)
    elif sharpnes == 3:
        value = soft(value)
    elif sharpnes == 4:
        value = sharp(value)
    elif sharpnes == 5:
        value = sharper(value)
    else:
        value = 1.0 - soft(value)

    return value


# vl_noise_turbulence:
def vlnTurbMode(coords, distort, basis, vlbasis, hardnoise):
    # hard noise
    if hardnoise:
        return (abs(-variable_lacunarity(coords, distort, noise_type1=basis, noise_type2=vlbasis)))
    # soft noise
    else:
        return variable_lacunarity(coords, distort, noise_type1=basis, noise_type2=vlbasis)


def vl_noise_turbulence(coords, distort, depth, basis, vlbasis, hardnoise, amp, freq):
    x, y, z = coords
    value = vlnTurbMode(coords, distort, basis, vlbasis, hardnoise)
    i = 0
    for i in range(depth):
        i += 1
        value += vlnTurbMode((x * (freq * i), y * (freq * i), z * (freq * i)),
                             distort, basis, vlbasis, hardnoise) * (amp * 0.5 / i)
    return value


# duo_multiFractal:
def double_multiFractal(coords, H, lacunarity, octaves, offset, gain, basis, vlbasis):
    x, y, z = coords
    n1 = multi_fractal((x * 1.5 + 1, y * 1.5 + 1, z * 1.5 + 1), 1.0, 1.0, 1.0, noise_basis=basis) * (offset * 0.5)
    n2 = multi_fractal((x - 1, y - 1, z - 1), H, lacunarity, octaves, noise_basis=vlbasis) * (gain * 0.5)
    return (n1 * n1 + n2 * n2) * 0.5


# distorted_heteroTerrain:
def distorted_heteroTerrain(coords, H, lacunarity, octaves, offset, distort, basis, vlbasis):
    x, y, z = coords
    h1 = (hetero_terrain((x, y, z), 1.0, 2.0, 1.0, 1.0, noise_basis=basis) * 0.5)
    d = h1 * distort
    h2 = (hetero_terrain((x + d, y + d, z + d), H, lacunarity, octaves, offset, noise_basis=vlbasis) * 0.25)
    return (h1 * h1 + h2 * h2) * 0.5


# SlickRock:
def slick_rock(coords, H, lacunarity, octaves, offset, gain, distort, basis, vlbasis):
    x, y, z = coords
    n = multi_fractal((x, y, z), 1.0, 2.0, 2.0, noise_basis=basis) * distort * 0.25
    r = ridged_multi_fractal((x + n, y + n, z + n), H, lacunarity, octaves, offset + 0.1, gain * 2, noise_basis=vlbasis)
    return (n + (n * r)) * 0.5


# vlhTerrain
def vl_hTerrain(coords, H, lacunarity, octaves, offset, basis, vlbasis, distort):
    x, y, z = coords
    ht = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, noise_basis=basis) * 0.25
    vl = ht * variable_lacunarity((x, y, z), distort, noise_type1=basis, noise_type2=vlbasis) * 0.5 + 0.5
    return vl * ht


# another turbulence
def ant_turbulence(coords, depth, hardnoise, nbasis, amp, freq, distortion):
    x, y, z = coords
    t = turbulence_vector((x / 2, y / 2, z / 2), depth, 0, noise_basis=nbasis,
                          amplitude_scale=amp, frequency_scale=freq) * 0.5 * distortion
    return turbulence((t[0], t[1], t[2]), 2, hardnoise, noise_basis="VORONOI_F1") * 0.5 + 0.5


# rocks noise
def rocks_noise(coords, depth, hardnoise, nbasis, distortion):
    x, y, z = coords
    p = turbulence((x, y, z), 4, 0, noise_basis='BLENDER') * 0.125 * distortion
    xx, yy, zz = x, y, z
    a = turbulence((xx + p, yy + p, zz), 2, 0, noise_basis='VORONOI_F2F1')
    pa = a * 0.1875 * distortion
    b = turbulence((x, y, z + pa), depth, hardnoise, noise_basis=nbasis)
    return ((a + 0.5 * (b - a)) * 0.5 + 0.5)


# shattered_hterrain:
def shattered_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
    x, y, z = coords
    d = (turbulence_vector(coords, 6, 0)[0] * 0.5 + 0.5) * distort * 0.5
    t1 = (turbulence_vector((x + d, y + d, z + d), 0, 0, noise_basis='VORONOI_F2F1')[0] + 0.5)
    t2 = (hetero_terrain((x * 2, y * 2, z * 2), H, lacunarity, octaves, offset, noise_basis=basis) * 0.5)
    return ((t1 * t2) + t2 * 0.5) * 0.5


# strata_hterrain
def strata_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
    x, y, z = coords
    value = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, noise_basis=basis) * 0.5
    steps = (sin(value * (distort * 5) * pi) * (0.1 / (distort * 5) * pi))
    return (value * (1.0 - 0.5) + steps * 0.5)


# Planet Noise by: Farsthary
# https://farsthary.com/2010/11/24/new-planet-procedural-texture/
def planet_noise(coords, oct=6, hard=0, noisebasis='PERLIN_ORIGINAL', nabla=0.001):
    x, y, z = coords
    d = 0.001
    offset = nabla * 1000
    x = turbulence((x, y, z), oct, hard, noise_basis=noisebasis)
    y = turbulence((x + offset, y, z), oct, hard, noise_basis=noisebasis)
    z = turbulence((x, y + offset, z), oct, hard, noise_basis=noisebasis)
    xdy = x - turbulence((x, y + d, z), oct, hard, noise_basis=noisebasis)
    xdz = x - turbulence((x, y, z + d), oct, hard, noise_basis=noisebasis)
    ydx = y - turbulence((x + d, y, z), oct, hard, noise_basis=noisebasis)
    ydz = y - turbulence((x, y, z + d), oct, hard, noise_basis=noisebasis)
    zdx = z - turbulence((x + d, y, z), oct, hard, noise_basis=noisebasis)
    zdy = z - turbulence((x, y + d, z), oct, hard, noise_basis=noisebasis)
    return (zdy - ydz), (zdx - xdz), (ydx - xdy)


# ----------------------------------------------------------------------
# v.1.04 Effect functions:

def maximum(a, b):
    if (a > b):
        b = a
    return b


def minimum(a, b):
    if (a < b):
        b = a
    return b


def Mix_Modes(a, b, mixfactor, mode):
    mode = int(mode)
    a = a * (1.0 - mixfactor)
    b = b * (1.0 + mixfactor)
    # 1  mix
    if mode == 0:
        return (a * (1.0 - 0.5) + b * 0.5)
    # 2  add
    elif mode == 1:
        return (a + b)
    # 3  sub.
    elif mode == 2:
        return (a - b)
    # 4  mult.
    elif mode == 3:
        return (a * b)
    # 5  abs diff.
    elif mode == 4:
        return (abs(a - b))
    # 6  screen
    elif mode == 5:
        return 1.0 - ((1.0 - a) * (1.0 - b) / 1.0)
    # 7  addmodulo
    elif mode == 6:
        return (a + b) % 1.0
    # 8  min.
    elif mode == 7:
        return minimum(a, b)
    # 9  max.
    elif mode == 8:
        return maximum(a, b)
    else:
        return 0


Bias_Types = [sin_bias, cos_bias, tri_bias, saw_bias, no_bias]
Sharp_Types = [soft, sharp, sharper]


# Transpose effect coords:
def Trans_Effect(coords, size, loc):
    x, y, z = coords
    x = (x * 2.0 / size + loc[0])
    y = (y * 2.0 / size + loc[1])
    return x, y, z


# Effect_Basis_Function:
def Effect_Basis_Function(coords, type, bias):
    bias = int(bias)
    type = int(type)
    x, y, z = coords
    iscale = 1.0
    offset = 0.0

    # gradient:
    if type == 1:
        effect = offset + iscale * (Bias_Types[bias](x + y))
    # waves / bumps:
    elif type == 2:
        effect = offset + iscale * 0.5 * (Bias_Types[bias](x * pi) + Bias_Types[bias](y * pi))
    # zigzag:
    elif type == 3:
        effect = offset + iscale * Bias_Types[bias](offset + iscale * sin(x * pi + sin(y * pi)))
    # wavy:
    elif type == 4:
        effect = offset + iscale * (Bias_Types[bias](cos(x) + sin(y) + cos(x * 2 + y * 2) - sin(-x * 4 + y * 4)))
    # sine bump:
    elif type == 5:
        effect = offset + iscale * 1 - Bias_Types[bias]((sin(x * pi) + sin(y * pi)))
    # dots:
    elif type == 6:
        effect = offset + iscale * (Bias_Types[bias](x * pi * 2) * Bias_Types[bias](y * pi * 2)) - 0.5
    # rings:
    elif type == 7:
        effect = offset + iscale * (Bias_Types[bias](1.0 - (x * x + y * y)))
    # spiral:
    elif type == 8:
        effect = offset + iscale * \
            Bias_Types[bias]((x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5)) * 2
    # square / piramide:
    elif type == 9:
        effect = offset + iscale * Bias_Types[bias](1.0 - sqrt((x * x)**10 + (y * y)**10)**0.1)
    # blocks:
    elif type == 10:
        effect = (0.5 - max(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    # grid:
    elif type == 11:
        effect = (0.025 - min(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    # tech:
    elif type == 12:
        a = max(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi))
        b = max(Bias_Types[bias](x * pi * 2 + 2), Bias_Types[bias](y * pi * 2 + 2))
        effect = min(Bias_Types[bias](a), Bias_Types[bias](b)) * 3.0 - 2.0
        if effect > 0.5:
            effect = 1.0
        effect = offset + iscale * effect
    # crackle:
    elif type == 13:
        t = turbulence((x, y, 0), 6, 0, noise_basis="BLENDER") * 0.25
        effect = variable_lacunarity((x, y, t), 0.25, noise_type2='VORONOI_CRACKLE')
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect
    # sparse cracks noise:
    elif type == 14:
        effect = 2.5 * abs(noise((x, y, 0), noise_basis="PERLIN_ORIGINAL")) - 0.1
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * (effect * 2.5)
    # shattered rock noise:
    elif type == 15:
        effect = 0.5 + noise((x, y, 0), noise_basis="VORONOI_F2F1")
        if effect > 0.75:
            effect = 0.75
        effect = offset + iscale * effect
    # lunar noise:
    elif type == 16:
        effect = 0.25 + 1.5 * voronoi((x, y, 0), distance_metric='DISTANCE_SQUARED')[0][0]
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect * 2
    # cosine noise:
    elif type == 17:
        effect = cos(5 * noise((x, y, 0), noise_basis="BLENDER"))
        effect = offset + iscale * (effect * 0.5)
    # spikey noise:
    elif type == 18:
        n = 0.5 + 0.5 * turbulence((x * 5, y * 5, 0), 8, 0, noise_basis="BLENDER")
        effect = ((n * n)**5)
        effect = offset + iscale * effect
    # stone noise:
    elif type == 19:
        effect = offset + iscale * (noise((x * 2, y * 2, 0), noise_basis="BLENDER") * 1.5 - 0.75)
    # Flat Turb:
    elif type == 20:
        t = turbulence((x, y, 0), 6, 0, noise_basis="BLENDER")
        effect = t * 2.0
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    # Flat Voronoi:
    elif type == 21:
        t = 1 - voronoi((x, y, 0), distance_metric='DISTANCE_SQUARED')[0][0]
        effect = t * 2 - 1.5
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    else:
        effect = 0.0

    if effect < 0.0:
        effect = 0.0

    return effect


# fractalize Effect_Basis_Function: ------------------------------
def Effect_Function(coords, type, bias, turb, depth, frequency, amplitude):

    x, y, z = coords
    # turbulence:
    if turb > 0.0:
        t = turb * (0.5 + 0.5 * turbulence(coords, 6, 0, noise_basis="BLENDER"))
        x = x + t
        y = y + t
        z = z + t

    result = Effect_Basis_Function((x, y, z), type, bias) * amplitude
    # fractalize:
    if depth != 0:
        i = 0
        for i in range(depth):
            i += 1
            x *= frequency
            y *= frequency
            result += Effect_Basis_Function((x, y, z), type, bias) * amplitude / i

    return result


# ------------------------------------------------------------
# landscape_gen
def noise_gen(coords, props):

    terrain_name = props[0]
    cursor = props[1]
    smooth = props[2]
    triface = props[3]
    sphere = props[4]
    land_mat = props[5]
    water_mat = props[6]
    texture_name = props[7]
    subd_x = props[8]
    subd_y = props[9]
    meshsize_x = props[10]
    meshsize_y = props[11]
    meshsize = props[12]
    rseed = props[13]
    x_offset = props[14]
    y_offset = props[15]
    z_offset = props[16]
    size_x = props[17]
    size_y = props[18]
    size_z = props[19]
    nsize = props[20]
    ntype = props[21]
    nbasis = props[22]
    vlbasis = props[23]
    distortion = props[24]
    hardnoise = int(props[25])
    depth = props[26]
    amp = props[27]
    freq = props[28]
    dimension = props[29]
    lacunarity = props[30]
    offset = props[31]
    gain = props[32]
    marblebias = int(props[33])
    marblesharpnes = int(props[34])
    marbleshape = int(props[35])
    height = props[36]
    height_invert = props[37]
    height_offset = props[38]
    maximum = props[39]
    minimum = props[40]
    falloff = int(props[41])
    edge_level = props[42]
    falloffsize_x = props[43]
    falloffsize_y = props[44]
    stratatype = props[45]
    strata = props[46]
    addwater = props[47]
    waterlevel = props[48]
    vert_group = props[49]
    remove_double = props[50]
    fx_mixfactor = props[51]
    fx_mix_mode = props[52]
    fx_type = props[53]
    fx_bias = props[54]
    fx_turb = props[55]
    fx_depth = props[56]
    fx_frequency = props[57]
    fx_amplitude = props[58]
    fx_size = props[59]
    fx_loc_x = props[60]
    fx_loc_y = props[61]
    fx_height = props[62]
    fx_offset = props[63]
    fx_invert = props[64]

    x, y, z = coords

    # Origin
    if rseed == 0:
        origin = x_offset, y_offset, z_offset
        origin_x = x_offset
        origin_y = y_offset
        origin_z = z_offset
        o_range = 1.0
    else:
        # Randomise origin
        o_range = 100
        seed_set(rseed)
        origin = random_unit_vector()
        ox = (origin[0] * o_range)
        oy = (origin[1] * o_range)
        oz = 0
        origin_x = (ox - (ox * 0.5)) + x_offset
        origin_y = (oy - (oy * 0.5)) + y_offset
        origin_z = oz + z_offset

    ncoords = (x / (nsize * size_x) + origin_x, y / (nsize * size_y) + origin_y, z / (nsize * size_z) + origin_z)

    # Noise type's
    if ntype in [0, 'multi_fractal']:
        value = multi_fractal(ncoords, dimension, lacunarity, depth, noise_basis=nbasis) * 0.5

    elif ntype in [1, 'ridged_multi_fractal']:
        value = ridged_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, noise_basis=nbasis) * 0.5

    elif ntype in [2, 'hybrid_multi_fractal']:
        value = hybrid_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, noise_basis=nbasis) * 0.5

    elif ntype in [3, 'hetero_terrain']:
        value = hetero_terrain(ncoords, dimension, lacunarity, depth, offset, noise_basis=nbasis) * 0.25

    elif ntype in [4, 'fractal']:
        value = fractal(ncoords, dimension, lacunarity, depth, noise_basis=nbasis)

    elif ntype in [5, 'turbulence_vector']:
        value = turbulence_vector(ncoords, depth, hardnoise, noise_basis=nbasis,
                                  amplitude_scale=amp, frequency_scale=freq)[0]

    elif ntype in [6, 'variable_lacunarity']:
        value = variable_lacunarity(ncoords, distortion, noise_type1=nbasis, noise_type2=vlbasis)

    elif ntype in [7, 'marble_noise']:
        value = marble_noise(
            (ncoords[0] - origin_x + x_offset),
            (ncoords[1] - origin_y + y_offset),
            (ncoords[2] - origin_z + z_offset),
            (origin[0] + x_offset, origin[1] + y_offset, origin[2] + z_offset), nsize,
            marbleshape, marblebias, marblesharpnes,
            distortion, depth, hardnoise, nbasis, amp, freq
        )
    elif ntype in [8, 'shattered_hterrain']:
        value = shattered_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)

    elif ntype in [9, 'strata_hterrain']:
        value = strata_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)

    elif ntype in [10, 'ant_turbulence']:
        value = ant_turbulence(ncoords, depth, hardnoise, nbasis, amp, freq, distortion)

    elif ntype in [11, 'vl_noise_turbulence']:
        value = vl_noise_turbulence(ncoords, distortion, depth, nbasis, vlbasis, hardnoise, amp, freq)

    elif ntype in [12, 'vl_hTerrain']:
        value = vl_hTerrain(ncoords, dimension, lacunarity, depth, offset, nbasis, vlbasis, distortion)

    elif ntype in [13, 'distorted_heteroTerrain']:
        value = distorted_heteroTerrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis, vlbasis)

    elif ntype in [14, 'double_multiFractal']:
        value = double_multiFractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis, vlbasis)

    elif ntype in [15, 'rocks_noise']:
        value = rocks_noise(ncoords, depth, hardnoise, nbasis, distortion)

    elif ntype in [16, 'slick_rock']:
        value = slick_rock(ncoords, dimension, lacunarity, depth, offset, gain, distortion, nbasis, vlbasis)

    elif ntype in [17, 'planet_noise']:
        value = planet_noise(ncoords, depth, hardnoise, nbasis)[2] * 0.5 + 0.5

    elif ntype in [18, 'blender_texture']:
        if texture_name != "" and texture_name in bpy.data.textures:
            value = bpy.data.textures[texture_name].evaluate(ncoords)[3]
        else:
            value = 0.0
    else:
        value = 0.5

    # Effect mix
    val = value
    if fx_type in [0, "0"]:
        fx_mixfactor = -1.0
        fxval = val
    else:
        fxcoords = Trans_Effect((x, y, z), fx_size, (fx_loc_x, fx_loc_y))
        effect = Effect_Function(fxcoords, fx_type, fx_bias, fx_turb, fx_depth, fx_frequency, fx_amplitude)
        effect = Height_Scale(effect, fx_height, fx_offset, fx_invert)
        fxval = Mix_Modes(val, effect, fx_mixfactor, fx_mix_mode)
    value = fxval

    # Adjust height
    value = Height_Scale(value, height, height_offset, height_invert)

    # Edge falloff:
    if not sphere:
        if falloff:
            ratio_x, ratio_y = abs(x) * 2 / meshsize_x, abs(y) * 2 / meshsize_y
            fallofftypes = [
                0,
                sqrt(ratio_y**falloffsize_y),
                sqrt(ratio_x**falloffsize_x),
                sqrt(ratio_x**falloffsize_x + ratio_y**falloffsize_y)
            ]
            dist = fallofftypes[falloff]
            value -= edge_level
            if dist < 1.0:
                dist = (dist * dist * (3 - 2 * dist))
                value = (value - value * dist) + edge_level
            else:
                value = edge_level

    # Strata / terrace / layers
    if stratatype not in [0, "0"]:
        if stratatype in [1, "1"]:
            strata = strata / height
            strata *= 2
            steps = (sin(value * strata * pi) * (0.1 / strata * pi))
            value = (value * 0.5 + steps * 0.5) * 2.0

        elif stratatype in [2, "2"]:
            strata = strata / height
            steps = -abs(sin(value * strata * pi) * (0.1 / strata * pi))
            value = (value * 0.5 + steps * 0.5) * 2.0

        elif stratatype in [3, "3"]:
            strata = strata / height
            steps = abs(sin(value * strata * pi) * (0.1 / strata * pi))
            value = (value * 0.5 + steps * 0.5) * 2.0

        elif stratatype in [4, "4"]:
            strata = strata / height
            value = int(value * strata) * 1.0 / strata

        elif stratatype in [5, "5"]:
            strata = strata / height
            steps = (int(value * strata) * 1.0 / strata)
            value = (value * (1.0 - 0.5) + steps * 0.5)

    # Clamp height min max
    if (value < minimum):
        value = minimum
    if (value > maximum):
        value = maximum

    return value
