orthographic/perlin.py

# -------------------------------------------------------------------
# ORTHOGRAPHIC
# Your personal aerial satellite. Always on. At any altitude.*
# Developed by MarStrMind
# License: Open Software License 3.0
# Up to date version always on marstr.online
# -------------------------------------------------------------------
# perlin.py
# Generates a perlin noise image which is used to determine how which
# resource looks.
# -------------------------------------------------------------------

from PIL import Image # Depends on the Pillow lib
from random import randrange
import random
import numpy as np
import glob
from defines import *
from perlin_numpy import (
    generate_perlin_noise_2d, generate_fractal_noise_2d
)

class mstr_perlin:

    def __init__(self, tag, value, mlat, mlng, zl):
        self._tag = tag
        self._value = value
        self._mlat = mlat
        self._mlng = mlng

        self._zl = zl
        self._mapscale = 0
        if zl == 16: self._mapscale = 80
        if zl == 18: self._mapscale = 20


    def _generateColorIndex(self):
        idx = []

        colorsrc = glob.glob(mstr_datafolder + "textures/" + self._tag + "/" + self._value + "/*.png")
        if len(colorsrc) >= 4:
            picknum = list(range(0, len(colorsrc)))
            picksel = random.sample(picknum, 4)

            for p in range(0, 4):
                ptc = Image.open(colorsrc[picksel[p]])
                ptc = ptc.resize((1,1), resample=Image.Resampling.BILINEAR)
                clr = ptc.getpixel((0,0))
                res = (clr[0], clr[1], clr[2])
                idx.append(res)

        return idx


    # Generates a Perlin map depending on what we need
    def _generatePerlinMap(self):
        #idx = self._findBaseColor()
        clr = self._generateColorIndex()
        bw = self._mlng * self._mapscale
        bh = self._mlat * self._mapscale
        base = Image.new("RGBA", (bw,bh))

        if len(clr) == 4:
            wh = 3000
            base = Image.new("RGBA", (bw,bh), clr[0])
            
            for c in range(len(clr)):
                np.random.seed(randrange(10000000, 100000000))
                noise1 = generate_fractal_noise_2d((wh,wh), (64,64), 5)
                np.random.seed(randrange(10000000, 100000000))
                noise2 = generate_fractal_noise_2d((wh,wh), (32,32), 4)

                im1 = Image.new("RGBA", (wh,wh))
                im2 = Image.new("RGBA", (wh,wh))
                
                for y in range(0, wh):
                    for x in range(0, wh):
                        n = (noise1[y][x] + 1) / 2
                        v = (
                            clr[c][0],
                            clr[c][1],
                            clr[c][2],
                            int(n*255)
                            )
                        im1.putpixel((x,y), v)
                        
                for y in range(0, wh):
                    for x in range(0, wh):
                        n = (noise2[y][x] + 1) / 2
                        v = (
                            clr[c][0],
                            clr[c][1],
                            clr[c][2],
                            int(n*255)
                            )
                        im2.putpixel((x,y), v)
                        
                im = Image.blend(im1,im2, alpha=0.675)
                base.alpha_composite(im)

        # Provide the perlin map
        return base