Terrain Generation Progress

Slowly but surely I am making progress on my terrain generation code. It took a while to understand which of the modern algorithms are generally employed for terrain creation. This is certainly a very interesting field unto itself. I know my brain is being challenged as I search for algorithms and practical implementations.

Despite the math part the hardest part so far has been to understand how to use the existing libraries for manipulating images. Most of the image libraries or image manipulation programs out there cannot handle 16 bit single channel greyscale images. Even the venerable GIMP will not be able to handle this format until version 2.10. That really surprised me. The reason this format is important is because most terrain programs spit out this format as a standardized format. You read that same file into GIMP and it squishes the data into an 8 bit format losing a lot of resolution.

I finally did find the libraries to do the manipulation and save to the proper formats:

1. PythonMagick (an ImageMagick wrapper for Python, missing lots of features of ImageMagick unfortunately). This is the program I use to write the 16 bit image files for using in terrain importing and generation.
2. Numpy/SciPy are two libraries I am using for handling the image data. I also intend to use the math functions there provide to do more advanced manipulation.
3. Noise is a Python library that does some Perlin noise generation. I used it in various combinations to produce the terrain in the screenshots.

Here is some code that does the terrain generation (just a code snippet):

def ter_genPlasma():
    octaves = 4
    freq = 64.0 * octaves

    random.seed()
    val = random.randint(0,256)
    rptx = random.randint(128,16535)
    rpty = random.randint(128,16535)
    data = numpy.array([0]*512*512,dtype=numpy.float32)
    for y in range(512):
        for x in range(512):
            fn = ((pnoise2(x / freq, y / freq, octaves, repeatx=rptx, repeaty=rpty, persistence=0.5, base=val) + 1.0)/2.0)*4096.0
            data[(x+y*512)] = fn

    octaves = 1
    freq = 128.0 * octaves
    val = random.randint(0,256)
    rptx = random.randint(128,16535)
    rpty = random.randint(128,16535)
    for y in range(512):
        for x in range(512):
            fn = ((pnoise2(x / freq, y / freq, octaves, persistence=0.5, base=val) + 1.0)/2.0)*16384.0
            #fn = ((snoise2(x / freq, y / freq) + 1.0)/2.0)*16384.0
            data[x+y*512] += fn
            pass

    octaves = 8
    freq = 4.0 * octaves
    val = random.randint(0,256)
    rptx = random.randint(128,16535)
    rpty = random.randint(128,16535)
    for y in range(512):
        for x in range(512):
            fn = ((pnoise2(x / freq, y / freq, octaves, persistence=0.5, base=val) + 1.0)/2.0)*2048.0
            data[x+y*512] += fn
            pass

    #data2 = numpy.multiply(data,32767)
    odata = data.astype(numpy.int16)

    size = "%sx%s" % (512, 512)
    mdata = PythonMagick.Blob(odata.tostring())
    image = PythonMagick.Image(mdata, size, 16, 'A')

    image.magick("png")
    image.defineValue("png","bit-depth","16")
    image.defineValue("png","color-type","0")

    return image

Here are some screenshots that the above code is producing:


As I experiment with the noise functions and how to combine them I realize that I am going to have to take a multi layer approach. Terrain is a combination of different forces working together. I also have been looking at terrain and thinking about what it took to create that environment. So I am going to take a hint from nature and build up some working models for how terrain will be formed and get the computer to do the work.

Some of the concepts I am thinking about for the layering are as follows:

1. Use a hardness map to determine the relative sub strata makeup of the terrain. Is it rock or dirt?
2. Set a median point for manipulation of the terrain. Things above this point will be mountainous, things below this point will be ravines cut from a flat area like the grand canyon. Islands are generally all mountainous in nature.
3. Map fault lines and use to make splits in the terrain and to form mountains.
4. Apply impact zones, volcano craters, etc.
5. Simulate water wear.
6. Map vegetation and factor that into erosion determination similar to the hardness map.

The multi layering should allow the terrain to be generated in such a way as to make it believable. Also, I am exploring which algorithms allow tiling in the math itself. This type of continuous calculation definitely is weighted toward Perlin calculations. The bifurcation algorithms do not lend themselves well to this.

So, onward and upward!