예제 #1
0
def create_island(seed, freq=3.5):
    w, h = 750, 512
    falloff = create_falloff(w, h)
    n1 = 1.000 * sn.generate_noise(w, h, freq * 1, seed + 0)
    n2 = 0.500 * sn.generate_noise(w, h, freq * 2, seed + 1)
    n3 = 0.250 * sn.generate_noise(w, h, freq * 4, seed + 2)
    n4 = 0.125 * sn.generate_noise(w, h, freq * 8, seed + 3)
    elevation = falloff * (falloff / 2 + n1 + n2 + n3 + n4)
    elevation = sn.generate_sdf(elevation < 0.4)
    elmax = max(abs(np.amin(elevation)), abs(np.amax(elevation)))
    return elevation / elmax
예제 #2
0
def create_wrap_figures():
    ground = snowy.load(qualify('ground.jpg'))
    hground = np.hstack([ground, ground])
    ground2x2 = np.vstack([hground, hground])
    snowy.export(ground2x2, qualify('ground2x2.jpg'))

    ground = snowy.blur(ground, radius=14, filter=snowy.LANCZOS)
    snowy.export(ground, qualify('blurry_ground_bad.jpg'))
    hground = np.hstack([ground, ground])
    ground2x2 = np.vstack([hground, hground])
    snowy.export(ground2x2, qualify('blurry_ground2x2_bad.jpg'))

    ground = snowy.load(qualify('ground.jpg'))

    ground = snowy.blur(ground,
                        radius=14,
                        wrapx=True,
                        wrapy=True,
                        filter=snowy.LANCZOS)
    snowy.export(ground, qualify('blurry_ground_good.jpg'))
    hground = np.hstack([ground, ground])
    ground2x2 = np.vstack([hground, hground])
    snowy.export(ground2x2, qualify('blurry_ground2x2_good.jpg'))

    n = snowy.generate_noise(256, 512, frequency=4, seed=42, wrapx=False)
    n = 0.5 + 0.5 * np.sign(n) - n
    n = np.hstack([n, n])
    n = snowy.add_border(n, width=4)
    snowy.export(n, qualify('tiled_noise_bad.png'))

    n = snowy.generate_noise(256, 512, frequency=4, seed=42, wrapx=True)
    n = 0.5 + 0.5 * np.sign(n) - n
    n = np.hstack([n, n])
    n = snowy.add_border(n, width=4)
    snowy.export(n, qualify('tiled_noise_good.png'))

    c0 = create_circle(400, 200, 0.3)
    c1 = create_circle(400, 200, 0.08, 0.8, 0.8)
    circles = np.clip(c0 + c1, 0, 1)
    mask = circles != 0.0
    sdf = snowy.unitize(snowy.generate_sdf(mask, wrapx=True, wrapy=True))
    sdf = np.hstack([sdf, sdf, sdf, sdf])
    sdf = snowy.resize(np.vstack([sdf, sdf]), width=512)
    sdf = snowy.add_border(sdf)
    snowy.export(sdf, qualify('tiled_sdf_good.png'))

    sdf = snowy.unitize(snowy.generate_sdf(mask, wrapx=False, wrapy=False))
    sdf = np.hstack([sdf, sdf, sdf, sdf])
    sdf = snowy.resize(np.vstack([sdf, sdf]), width=512)
    sdf = snowy.add_border(sdf)
    snowy.export(sdf, qualify('tiled_sdf_bad.png'))
예제 #3
0
def create_island(seed, gradient, freq=3.5):
    w, h = 750, 512
    falloff = create_falloff(w, h)
    n1 = 1.000 * snowy.generate_noise(w, h, freq*1, seed+0)
    n2 = 0.500 * snowy.generate_noise(w, h, freq*2, seed+1)
    n3 = 0.250 * snowy.generate_noise(w, h, freq*4, seed+2)
    n4 = 0.125 * snowy.generate_noise(w, h, freq*8, seed+3)
    elevation = falloff * (falloff / 2 + n1 + n2 + n3 + n4)
    mask = elevation < 0.4
    elevation = snowy.unitize(snowy.generate_sdf(mask))
    if GRAY_ISLAND:
        return (1 - mask) * np.power(elevation, 3.0)
    elevation = snowy.generate_sdf(mask) - 100 * n4
    mask = np.where(elevation < 0, 1, 0)
    el = 128 + 127 * elevation / np.amax(elevation)
    return applyColorGradient(el, gradient)
예제 #4
0
파일: test_snowy.py 프로젝트: wsf1990/snowy
def test_tileable():
    n = snowy.generate_noise(200, 400, frequency=4, seed=42, wrapx=True)
    n = 0.5 + 0.5 * np.sign(n) - n
    n = np.hstack([n, n])
    gold = snowy.resize(n, 200, 200)

    n = snowy.generate_noise(20, 40, frequency=4, seed=42, wrapx=True)
    n = 0.5 + 0.5 * np.sign(n) - n
    n = snowy.resize(n, 100, 200)
    bad = np.hstack([n, n])

    n = snowy.generate_noise(20, 40, frequency=4, seed=42, wrapx=True)
    n = 0.5 + 0.5 * np.sign(n) - n
    n = snowy.resize(n, 100, 200, wrapx=True)
    good = np.hstack([n, n])

    snowy.show(snowy.hstack([gold, bad, good], 2, .7))
예제 #5
0
파일: test_snowy.py 프로젝트: wsf1990/snowy
def test_minification():
    n = snowy.generate_noise(1000, 1000, frequency=5, seed=42)
    n = 0.5 + 0.5 * np.sign(n)
    a = snowy.resize(n, 100, 100)
    b = snowy.resize(n, 100, 100, snowy.MITCHELL)
    c = snowy.resize(n, 100, 100, snowy.GAUSSIAN)
    d = snowy.resize(n, 100, 100, snowy.NEAREST)
    x = [a, b, c, d] + [create_circle(100, 100)]
    snowy.show(np.hstack(x))
예제 #6
0
def test_tweet():
    import snowy as sn, numpy as np
    im = sn.generate_noise(2000, 500, 5, seed=2, wrapx=True)
    df = sn.generate_sdf(im < 0.0, wrapx=True)
    im = 0.5 + 0.5 * np.sign(im) - im
    cl = lambda L, U: np.where(np.logical_and(df > L, df < U), -im, 0)
    im += cl(20, 30) + cl(60, 70) + cl(100, 110)

    sn.show(sn.resize(im, height=100, wrapx=True))
    sn.show(sn.resize(np.hstack([im, im]), height=200, wrapx=True))
예제 #7
0
# Test rotations and flips

gibbons = snowy.load(qualify('gibbons.jpg'))
gibbons = snowy.resize(gibbons, width=gibbons.shape[1] // 5)
gibbons90 = snowy.rotate(gibbons, 90)
gibbons180 = snowy.rotate(gibbons, 180)
gibbons270 = snowy.rotate(gibbons, 270)
hflipped = snowy.hflip(gibbons)
vflipped = snowy.vflip(gibbons)
snowy.export(snowy.hstack([gibbons, gibbons180, vflipped],
    border_width=4, border_value=[0.5,0,0]), qualify("xforms.png"))

# Test noise generation

n = snowy.generate_noise(100, 100, frequency=4, seed=42, wrapx=True)
n = np.hstack([n, n])
n = 0.5 + 0.5 * n
snowy.show(n)
snowy.export(n, qualify('noise.png'))

# First try minifying grayscale

gibbons = snowy.load(qualify('snowy.jpg'))
gibbons = np.swapaxes(gibbons, 0, 2)
gibbons = np.swapaxes(gibbons[0], 0, 1)
gibbons = snowy.reshape(gibbons)
source = snowy.resize(gibbons, height=200)
blurry = snowy.blur(source, radius=4.0)
diptych_filename = qualify('diptych.png')
snowy.export(snowy.hstack([source, blurry]), diptych_filename)
예제 #8
0
파일: test_snowy.py 프로젝트: wsf1990/snowy
def test_noise_smoothness():
    noise = 0.5 + 0.5 * snowy.generate_noise(300, 150, 4, seed=42)
    grad = snowy.gradient(noise)
    grad = grad[0] + grad[1]
    grad = snowy.unitize(grad)
    snowy.show(grad)