├── tests
    ├── nim.cfg
    ├── gridpngs.nim
    ├── islands.nim
    └── zoom.nim
├── islands.png
├── .gitignore
├── src
    ├── nile.nim
    ├── io.nim
    ├── canvas.nim
    ├── vector.nim
    ├── noise.nim
    ├── distance.nim
    ├── image.nim
    ├── filter.nim
    └── grid.nim
├── LICENSE
└── README.md


/tests/nim.cfg:
--------------------------------------------------------------------------------
1 | --path:"../src/"
2 | 


--------------------------------------------------------------------------------
/islands.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/prideout/nile/HEAD/islands.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | nimcache
2 | *.png
3 | .vscode
4 | tests/*
5 | !tests/*.nim
6 | default.profraw
7 | -islands.png
8 | 


--------------------------------------------------------------------------------
/src/nile.nim:
--------------------------------------------------------------------------------
1 | include grid
2 | include noise
3 | include distance
4 | include image
5 | include io
6 | include vector
7 | include canvas
8 | include filter
9 | 


--------------------------------------------------------------------------------
/src/io.nim:
--------------------------------------------------------------------------------
 1 | import grid
 2 | import image
 3 | import nimPNG
 4 | 
 5 | proc savePNG*(g: Grid, filename: string): void =
 6 |     discard savePNG(filename, g.toDataString(), LCT_GREY, 8, g.width, g.height)
 7 | 
 8 | proc savePNG*(img: Image, filename: string): void =
 9 |     discard savePNG(filename, img.toDataString(), LCT_RGBA, 8, img.width, img.height)
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Philip Rideout
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/canvas.nim:
--------------------------------------------------------------------------------
 1 | import cairo
 2 | import image
 3 | import math
 4 | import vector
 5 | 
 6 | type
 7 |     Canvas* = ref object
 8 |         data*: string
 9 |         width*, height*: int
10 |         surface: PSurface
11 |         context: PContext
12 | 
13 | proc newCanvas*(width, height: int): Canvas =
14 |     new(result)
15 |     result.data = newString(width * height * 4)
16 |     result.width = width
17 |     result.height = height
18 |     let
19 |         w32 = int32(width)
20 |         h32 = int32(height)
21 |         stride = int32(width * 4)
22 |     result.surface = image_surface_create(cstring(result.data), FORMAT_ARGB32, w32, h32, stride)
23 |     result.context = result.surface.create()
24 |     result.context.scale float64(width), float64(width)
25 |     result.context.setLineWidth(0.005)
26 | 
27 | proc toImage*(c: Canvas): Image = newImageFromDataString(c.data, c.width, c.height)
28 | 
29 | proc scale*(c: Canvas; x, y: float): auto =
30 |     c.context.scale(x, y); c
31 | 
32 | proc setLineWidth*(c: Canvas; width: float): auto =
33 |     c.context.set_line_width(width); c
34 | 
35 | proc setColor*(c: Canvas; red, grn, blu, alp: float): auto =
36 |     c.context.setSourceRgba(red, grn, blu, alp); c
37 | 
38 | proc stroke*(c: Canvas): auto {.discardable.} =
39 |     c.context.stroke; c
40 | 
41 | proc fill*(c: Canvas): auto {.discardable.} =
42 |     c.context.fill; c
43 | 
44 | proc moveTo*(c: Canvas; pt: Vec2f): auto =
45 |     c.context.move_to(pt.x, pt.y); c
46 | 
47 | proc lineTo*(c: Canvas; pt: Vec2f): auto =
48 |     c.context.line_to(pt.x, pt.y); c
49 | 
50 | proc circle*(c: Canvas; pt: Vec2f, radius: float): auto =
51 |     let ctx = c.context; ctx.save()
52 |     ctx.translate(pt.x, pt.y)
53 |     ctx.scale(radius, radius)
54 |     ctx.arc(0, 0, 1, 0, 2 * PI)
55 |     ctx.restore(); c
56 | 


--------------------------------------------------------------------------------
/tests/gridpngs.nim:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env nim c --run
 2 | 
 3 | import nile
 4 | 
 5 | const diagramScale = 16
 6 | 
 7 | let original = newGrid("""
 8 |     00000000
 9 |     00111100
10 |     00100100
11 |     00111100
12 |     00100000
13 |     00100000
14 |     00100000
15 |     00000000""")
16 | original.setPixel(7, 7, 0.5)
17 | var mag = original.resizeBoxFilter(11, 11).resizeNearestFilter(diagramScale).drawGrid(11, 11)
18 | var ide = original.resizeBoxFilter(8, 8).resizeNearestFilter(diagramScale).drawGrid(8, 8)
19 | var min = original.resizeBoxFilter(5, 5).resizeNearestFilter(diagramScale).drawGrid(5, 5)
20 | min.savePNG("min0.png")
21 | mag.savePNG("mag0.png")
22 | ide.savePNG("ide0.png")
23 | 
24 | let tiny = newGrid("000 010 000")
25 | min = tiny.resizeBoxFilter(1, 1).resizeNearestFilter(diagramScale).drawGrid(1, 1)
26 | mag = tiny.resizeBoxFilter(5, 5).resizeNearestFilter(diagramScale).drawGrid(5, 5)
27 | ide = tiny.resizeBoxFilter(9, 9).resizeNearestFilter(diagramScale).drawGrid(9, 9)
28 | min.savePNG("min1.png")
29 | mag.savePNG("mag1.png")
30 | ide.savePNG("ide1.png")
31 | 
32 | let row = newGrid("010")
33 | mag = row.resize(5, 1, FilterHermite).resizeNearestFilter(diagramScale).drawGrid(5, 1, 1)
34 | mag.savePNG("mag2.png")
35 | mag = tiny.resize(5, 5, FilterHermite).resizeNearestFilter(diagramScale).drawGrid(5, 5, 1)
36 | mag.savePNG("mag3.png")
37 | mag = tiny.resize(128, 128, FilterHermite).drawGrid(1, 1, 1)
38 | mag.savePNG("mag4.png")
39 | 
40 | let nearest = original.resizeNearestFilter(1000, 1000).resizeBoxFilter(100, 100)
41 | let hermite = original.resize(1000, 1000, FilterHermite).resizeBoxFilter(100, 100)
42 | let gauss = original.resize(1000, 1000, FilterGaussian).resizeBoxFilter(100, 100)
43 | let triangle = original.resize(1000, 1000, FilterTriangle).resizeBoxFilter(100, 100)
44 | (1 - hstack(nearest, hermite, gauss, triangle)).drawGrid(4, 1, 1).savePNG("min2.png")
45 | (0.2 + 0.5 * vstack(nearest, hermite, gauss, triangle)).drawGrid(1, 4, 1).savePNG("min3.png")
46 | 
47 | let grads = 0.5f + generateGradientNoise(42, 256, 256, 2.0f) * 0.5f
48 | grads.drawGrid(1, 1, 1).savePNG("grads1.png")
49 | 


--------------------------------------------------------------------------------
/src/vector.nim:
--------------------------------------------------------------------------------
 1 | import math
 2 | 
 3 | type
 4 |     Vec2f* = tuple[x, y: float32]
 5 |     Vec2i* = tuple[x, y: int32]
 6 |     Vec3f* = tuple[x, y, z: float32]
 7 |     Vec3ii* = tuple[x, y, z: int64]
 8 |     Viewport* = tuple[left, top, right, bottom: float32]
 9 | 
10 | const ENTIRE* = (0.0f, 0.0f, 1.0f, 1.0f)
11 | 
12 | proc `*`*(a: Vec2f, b: Vec2f): Vec2f = (a.x * b.x, a.y * b.y)
13 | proc `*`*(a: Vec2f, b: float32): Vec2f = (a.x * b, a.y * b)
14 | proc `*`*(a: float32, b: Vec2f): Vec2f = (a * b.x, a * b.y)
15 | proc `/`*(a: Vec2f, b: float32): Vec2f = (a.x / b, a.y / b)
16 | proc `+`*(a: Vec2f, b: float32): Vec2f = (a.x + b, a.y + b)
17 | proc `-`*(a: Vec2f, b: float32): Vec2f = (a.x - b, a.y - b)
18 | proc `+`*(a: Vec2f, b: Vec2f): Vec2f = (a.x + b.x, a.y + b.y)
19 | proc `-`*(a: Vec2f, b: Vec2f): Vec2f = (a.x - b.x, a.y - b.y)
20 | proc `+`*(a: Vec2i, b: int32): Vec2i = (a.x + b, a.y + b)
21 | proc `-`*(a: Vec2i, b: int32): Vec2i = (a.x - b, a.y - b)
22 | proc `+`*(a: Vec2i, b: Vec2i): Vec2i = (a.x + b.x, a.y + b.y)
23 | proc `-`*(a: Vec2i, b: Vec2i): Vec2i = (a.x - b.y, a.y - b.y)
24 | 
25 | proc `+`*(a: Vec3f, b: Vec3f): Vec3f = (a.x + b.x, a.y + b.y, a.z + b.z)
26 | proc `-`*(a: Vec3f, b: Vec3f): Vec3f = (a.x - b.x, a.y - b.y, a.z - b.z)
27 | proc `/`*(a: Vec3f, b: float32): Vec3f = (a.x / b, a.y / b, a.z / b)
28 | 
29 | 
30 | proc `+=`*(a: var Vec2f, b: Vec2f): void =
31 |     a.x += b.x
32 |     a.y += b.y
33 | 
34 | proc `+=`*(a: var Vec3f, b: Vec3f): void =
35 |     a.x += b.x
36 |     a.y += b.y
37 |     a.z += b.z
38 |     
39 | proc dot*(a: Vec2f, b: Vec2f): auto = a.x * b.x + a.y * b.y
40 | proc len*(v: Vec2f): auto = sqrt(dot(v, v))
41 | proc hat*(v: Vec2f): auto = v / v.len()
42 | 
43 | proc lower*(vp: Viewport): Vec2f = (x: vp.left, y: vp.top)
44 | proc upper*(vp: Viewport): Vec2f = (x: vp.right, y: vp.bottom)
45 | proc center*(vp: Viewport): Vec2f = (vp.lower() + vp.upper()) / 2
46 | proc size*(vp: Viewport): Vec2f = vp.upper() - vp.lower()
47 | proc viewport*(lower, upper: Vec2f): Viewport = (lower.x, lower.y, upper.x, upper.y)
48 | 
49 | proc `*`*(vp: Viewport, scale: float32): Viewport =
50 |     (vp.left * scale, vp.top * scale, vp.right * scale, vp.bottom * scale)
51 | 


--------------------------------------------------------------------------------
/src/noise.nim:
--------------------------------------------------------------------------------
 1 | import math
 2 | import hashes
 3 | import random
 4 | import grid
 5 | import vector
 6 | 
 7 | type
 8 |     GradientNoiseTable = ref object
 9 |         seed: int
10 |         size: int
11 |         mask: int32
12 |         gradients: seq[Vec2f]
13 |         indices: seq[int32]
14 | 
15 | proc fract(f: float32): float32 = f - floor(f)
16 | 
17 | proc newGradientNoiseTable*(seed: int): GradientNoiseTable =
18 |     result = new GradientNoiseTable
19 |     result.seed = seed
20 |     result.size = 256
21 |     result.mask = int32(result.size - 1)
22 |     result.gradients = newSeq[Vec2f](result.size)
23 |     result.indices = newSeq[int32](result.size)
24 |     for i in 0..result.mask:
25 |         result.indices[i] = int32(i)
26 |         result.gradients[i].x = cos(float32(i) * 2 * PI / float32(result.size))
27 |         result.gradients[i].y = sin(float32(i) * 2 * PI / float32(result.size))
28 |     var rnd = initRand(seed)
29 |     rnd.shuffle(result.indices)
30 | 
31 | proc getGradient(table: GradientNoiseTable, p: Vec2i): Vec2f =
32 |     var h: Hash = 0
33 |     h = h !& p.x
34 |     h = h !& p.y
35 |     h = (!$h)
36 |     table.gradients[table.indices[h and table.mask]]
37 | 
38 | proc computeNoiseValue*(table: GradientNoiseTable, x, y: float32): float32 =
39 |     let
40 |         i = (x: int32(floor(x)), y: int32(floor(y)))
41 |         f = (fract(x), fract(y))
42 |         u = f*f*f*(f*(f*6.0f - 15.0f) + 10.0f)
43 |         ga = table.getGradient(i + (0'i32,0'i32) )
44 |         gb = table.getGradient(i + (1'i32,0'i32) )
45 |         gc = table.getGradient(i + (0'i32,1'i32) )
46 |         gd = table.getGradient(i + (1'i32,1'i32) )
47 |         va = dot(ga, f - (0'f32,0'f32))
48 |         vb = dot(gb, f - (1'f32,0'f32))
49 |         vc = dot(gc, f - (0'f32,1'f32))
50 |         vd = dot(gd, f - (1'f32,1'f32))
51 |     va + u.x * (vb-va) + u.y * (vc-va) + u.x * u.y * (va-vb-vc+vd)
52 | 
53 | # Creates a scalar field with C1 continuity whose values are roughly in [-0.8, +0.8]
54 | # The viewport that spans from [-1,-1] to [+1,+1] is a 2x2 grid of surflets.
55 | proc generateGradientNoise*(seed: int; width, height: int; viewport: Viewport): Grid =
56 |     result = newGrid(width, height)
57 |     let
58 |         table = newGradientNoiseTable(seed)
59 |         vpwidth = viewport.right - viewport.left
60 |         vpheight = viewport.bottom - viewport.top
61 |         dx = vpwidth / float32(width)
62 |         sx = viewport.left + dx / 2
63 |         dy = vpheight / float32(height)
64 |         sy = viewport.top + dy / 2
65 |     var i = 0
66 |     for row in 0..<height:
67 |         let y = sy - float32(row) * dy
68 |         for col in 0..<width:
69 |             let x = sx + float32(col) * dx
70 |             result.data[i] = table.computeNoiseValue(x, y)
71 |             inc i
72 | 
73 | # Creates a scalar field with C1 continuity whose values are roughly in [-0.8, +0.8]
74 | # Frequency of 1.0 corresponds to a 2x2 grid of surflets.
75 | proc generateGradientNoise*(seed: int; width, height: int; frequency: float32): Grid =
76 |     # TODO: pay attention to aspect ratio
77 |     let f = frequency
78 |     let viewport = (-f, -f, f, f)
79 |     generateGradientNoise(seed, width, height, viewport)
80 | 


--------------------------------------------------------------------------------
/src/distance.nim:
--------------------------------------------------------------------------------
  1 | import grid
  2 | import math
  3 | 
  4 | const INF: float32 = 1e20
  5 | 
  6 | type Viewf = object
  7 |   data: ptr seq[float32]
  8 |   offset: int
  9 | 
 10 | type Viewi = object
 11 |   data: ptr seq[uint16]
 12 |   offset: int
 13 | 
 14 | proc get(g: Grid, x, y: int): float32 = g.data[y * g.width + x]
 15 | proc set(g: Grid, x, y: int, v: float32): void = g.data[y * g.width + x] = v
 16 | proc `[]=`(sv: Viewi, i: int, val: uint16): void = sv.data[sv.offset + i] = val
 17 | proc `[]=`(sv: Viewf, i: int, val: float32): void = sv.data[sv.offset + i] = val
 18 | proc `[]`(sv: Viewi, i: int): uint16 = sv.data[sv.offset + i]
 19 | proc `[]`(sv: Viewf, i: int): float32 = sv.data[sv.offset + i]
 20 | proc `[]`(sv: Viewf, i: uint16): float32 = sv.data[sv.offset + int(i)]
 21 | proc sqr(v: float32): float32 = v * v
 22 | proc sqr(v: uint16): float32 = float32(v) * float32(v)
 23 | proc sqr(v: int): float32 = float32(v * v)
 24 | 
 25 | # Low-level function that operates on a single row or column.
 26 | proc edt(f, d, z: Viewf, w: Viewi, n: int): void =
 27 |     var k: int = 0
 28 |     w[0] = 0
 29 |     z[0] = -INF
 30 |     z[1] = +INF
 31 |     for q in 1..<n:
 32 |         let q2 = float(q) * 2.0f
 33 |         var s = ((f[q] + sqr(q)) - (f[w[k]] + sqr(w[k]))) / (q2 - 2 * float(w[k]))
 34 |         while s <= z[k]:
 35 |             dec k
 36 |             s = ((f[q] + sqr(q)) - (f[w[k]] + sqr(w[k]))) / (q2 - 2 * float(w[k]))
 37 |         inc k
 38 |         w[k] = uint16(q)
 39 |         z[k] = s
 40 |         z[k + 1] = +INF
 41 |     k = 0
 42 |     for q in 0..<n:
 43 |         while z[k + 1] < float32(q):
 44 |             inc k
 45 |         d[q] = sqr(float32(q) - float32(w[k])) + f[w[k]]
 46 | 
 47 | proc createEdt*(grid: Grid): Grid =
 48 |     new(result)
 49 |     var
 50 |         width = grid.width
 51 |         height = grid.height
 52 |         npixels = width * height
 53 |         ff = newGrid(width, height)
 54 |         dd = newGrid(width, height)
 55 |         zz = newGrid(width + 1, height + 1)
 56 |         ww = newSeq[uint16](npixels)
 57 | 
 58 |     # Create a field of 0 and INF
 59 |     result.width = width
 60 |     result.height = height
 61 |     result.data = newSeq[float32](npixels)
 62 |     for n in 0..<npixels:
 63 |         result.data[n] = if grid.data[n] <= 0: 0.0f else: INF
 64 | 
 65 |     # Process columns
 66 |     for x in 0..<width:
 67 |         var
 68 |             f = Viewf(data: addr ff.data, offset: height * x)
 69 |             d = Viewf(data: addr dd.data, offset: height * x)
 70 |             z = Viewf(data: addr zz.data, offset: (height + 1) * x)
 71 |             w = Viewi(data: addr ww, offset: height * x)
 72 |         for y in 0..<height:
 73 |             f[y] = result.get(x, y)
 74 |         edt(f, d, z, w, height)
 75 |         for y in 0..<height:
 76 |             result.set(x, y, d[y])
 77 | 
 78 |     # Processing rows
 79 |     for y in 0..<height:
 80 |         var
 81 |             f = Viewf(data: addr ff.data, offset: width * y)
 82 |             d = Viewf(data: addr dd.data, offset: width * y)
 83 |             z = Viewf(data: addr zz.data, offset: (width + 1) * y)
 84 |             w = Viewi(data: addr ww, offset: width * y)
 85 |         for x in 0..<width:
 86 |             f[x] = result.get(x, y)
 87 |         edt(f, d, z, w, width)
 88 |         for x in 0..<width:
 89 |             result.set(x, y, d[x])
 90 | 
 91 |     # Post-process by square-rooting and normalizing
 92 |     let inv = 1.0 / float32(width)
 93 |     for n in 0..<npixels:
 94 |         result.data[n] = sqrt(result.data[n]) * inv
 95 | 
 96 | proc createSdf*(grid: Grid): Grid =
 97 |     var
 98 |         width = grid.width
 99 |         height = grid.height
100 |         npixels = width * height
101 |         positive = createEdt(grid)
102 |         negative = createEdt(1.0 - grid)
103 |     new(result)
104 |     result.width = grid.width
105 |     result.height = grid.height
106 |     result.data = newSeq[float32](npixels)
107 |     for n in 0..<npixels:
108 |         result.data[n] = positive.data[n] - negative.data[n]
109 | 


--------------------------------------------------------------------------------
/tests/islands.nim:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env nim c -d:release --boundChecks:off --verbosity:0 --run
  2 | 
  3 | import strformat
  4 | import nile
  5 | import os
  6 | 
  7 | const VIEWPORT_RESOLUTION = 256
  8 | const TILE_RESOLUTION = 2048
  9 | 
 10 | const SMOOTH_PALETTE = @[
 11 |     000, 0x001070 , # Dark Blue
 12 |     126, 0x2C5A7C , # Light Blue
 13 |     127, 0xE0F0A0 , # Yellow
 14 |     128, 0x5D943C , # Dark Green
 15 |     160, 0x606011 , # Brown
 16 |     200, 0xFFFFFF , # White
 17 |     255, 0xFFFFFF ] # White
 18 | 
 19 | const STEPPED_PALETTE = @[
 20 |     000, 0x2C316F ,
 21 |     125, 0x2C316F ,
 22 |     125, 0x46769D ,
 23 |     126, 0x46769D ,
 24 |     127, 0x324060 ,
 25 |     131, 0x324060 ,
 26 |     132, 0x9C907D ,
 27 |     137, 0x9C907D ,
 28 |     137, 0x719457 ,
 29 |     155, 0x719457 , # Light green
 30 |     155, 0x50735A ,
 31 |     180, 0x50735A ,
 32 |     180, 0x9FA881 ,
 33 |     200, 0x9FA881 ,
 34 |     200, 0xFFFFFF ,
 35 |     255, 0xFFFFFF ]
 36 | 
 37 | # Generate a "radiating" palette at compile time.
 38 | proc makeGray: seq[int] =
 39 |     result = newSeq[int]()
 40 |     var i = 0
 41 |     while i < 120:
 42 |         result.add(i); result.add(0xFFFFFF)
 43 |         i += 4
 44 |         let
 45 |             r = 200 - i * 2
 46 |             c = r or (r shl 8) or (r shl 16)
 47 |         result.add(i); result.add(c)
 48 |         result.add(i); result.add(0xFFFFFF)
 49 |         i += 15
 50 |     result.add(127); result.add(0x900000)
 51 |     result.add(128); result.add(0x900000)
 52 |     result.add(129); result.add(0x909090)
 53 |     result.add(255); result.add(0x707070)
 54 | const GRAY_PALETTE = makeGray()
 55 | 
 56 | type Map = ref object
 57 |     resolution: int
 58 |     seed: int
 59 | 
 60 | type Tile = ref object
 61 |     distance*: Grid
 62 |     mask*: Grid
 63 |     noise*: Grid
 64 |     elevation*: Grid
 65 |     index*: Vec3ii
 66 |     offset*: float
 67 |     map: Map
 68 |     children: array[4, Tile]
 69 | 
 70 | proc generateFalloff(size: int, view: Viewport): Grid =
 71 |     result = newGrid(size, size)
 72 |     let
 73 |         dx = (view.right - view.left) / float32(size)
 74 |         dy = (view.bottom - view.top) / float32(size)
 75 |     var y = view.top
 76 |     var i = 0
 77 |     for row in 0..<size:
 78 |         var x = view.left
 79 |         for col in 0..<size:
 80 |             let
 81 |                 t = len((x,y) - (0.5f, 0.5f))
 82 |                 v = FilterHermite.function(t)
 83 |             result.data[i] = v * v * v
 84 |             inc i
 85 |             x += dx
 86 |         y += dy
 87 | 
 88 | proc generateRootTile(resolution, seed: int): Tile =
 89 |     let
 90 |         size = resolution
 91 |         view = ENTIRE
 92 |         falloff = generateFalloff(size, view)
 93 |         vp0 = view * 4.0f
 94 |         vp1 = vp0 * 2.0f
 95 |         vp2 = vp1 * 2.0f
 96 |         vp3 = vp2 * 2.0f
 97 |         vp4 = vp3 * 2.0f
 98 |     new(result)
 99 |     result.index = (0'i64, 0'i64, 0'i64)
100 |     result.map = new Map
101 |     result.map.resolution = resolution
102 |     result.map.seed = seed
103 |     var g = generateGradientNoise(seed, size, size, vp0)
104 |     g *= 2.0f
105 |     g += generateGradientNoise(seed + 1, size, size, vp1)
106 |     g *= 2.0f
107 |     g += generateGradientNoise(seed + 2, size, size, vp2)
108 |     g *= 2.0f
109 |     g += generateGradientNoise(seed + 3, size, size, vp3)
110 |     g *= 2.0f
111 |     g += generateGradientNoise(seed + 4, size, size, vp4)
112 |     g /= 16
113 |     g += falloff / 2
114 |     g *= falloff
115 |     result.noise = g * 1.0
116 |     result.mask = g.step(0.1)
117 |     g = createSdf(result.mask)
118 |     result.offset = 0.0
119 |     var
120 |         lower = min(g)
121 |         upper = max(g)
122 |     result.distance = (g - lower) / (upper - lower)
123 |     result.offset = (result.offset - lower) / (upper - lower)
124 |     result.elevation = result.distance - result.offset
125 |     result.elevation -= 0.5 * result.elevation * result.noise
126 |     result.elevation += 0.5
127 | 
128 | proc showPNG(fname: string): void =
129 |     if 0 == execShellCmd fmt"which -s imgcat":
130 |         discard execShellCmd fmt"imgcat {fname}"
131 |     else:
132 |         echo fmt"Generated {fname}"
133 | 
134 | proc genIsland(palette: seq[int], seed: int): Image =
135 |     let
136 |         tile = generateRootTile(TILE_RESOLUTION, seed)
137 |         gradient = newColorGradient(palette)
138 |         el = tile.distance - tile.offset
139 | 
140 |     # Apply some of the noise to the SDF before rendering.
141 |     for i in 0..<el.data.len():
142 |         el.data[i] -= 0.5 * el.data[i] * tile.noise.data[i]
143 | 
144 |     var image = newImageFromLuminance(0.5 + el)
145 |     image.applyColorGradient(gradient)
146 |     image.resize(VIEWPORT_RESOLUTION, VIEWPORT_RESOLUTION, FilterHermite)
147 |     image
148 | 
149 | let
150 |     island0 = genIsland(STEPPED_PALETTE, 9)
151 |     island1 = genIsland(SMOOTH_PALETTE, 22)
152 |     island2 = genIsland(GRAY_PALETTE, 1)
153 |     image = hstack(island0, island1, island2)
154 |     fname = fmt"islands.png"
155 | 
156 | image.drawGrid(3, 1)
157 | image.savePNG(fname)
158 | showPNG(fname)
159 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <img src="https://github.com/prideout/nile/raw/master/islands.png" width="320">
  2 | 
  3 | **Nile** generates height maps and images for imaginary islands. It includes:
  4 | 
  5 | - Efficient high-quality resampling of floating-point images. (`filter.nim`)
  6 | - Efficient computation of signed distance fields. (`distance.nim`)
  7 | - Tweakable generation of gradient noise. (`noise.nim`)
  8 | 
  9 | To try it out, do:
 10 | 
 11 | `nim c --run tests/islands.nim`
 12 | 
 13 | Alternatively, simply invoke `islands.nim` directly from your shell since it has a shebang. This
 14 | will enable the release flag, creating a very fast native executable.
 15 | 
 16 | <!--
 17 | 
 18 | # INFINITE ISLAND
 19 | 
 20 |     Linearize the color gradient (see newColorGradient)
 21 | 
 22 |     Magnification of the DF should perhaps be MIN
 23 | 
 24 |     Window is 960x540
 25 |     Viewport is 960x960
 26 |     BaseTile (L_f32) and CurrentTile (L_f32) are both 3840x3840.
 27 |     Initial Viewport is 0.375,0.375 through 0.625, 0.625
 28 | 
 29 |     see notes later in this file
 30 | 
 31 |     https://twitter.com/fenharel/status/1023968156203663360
 32 |     https://www.danielsmaps.com/portfolio/
 33 | 
 34 |     making video
 35 |         import os
 36 |         execShellCmd(command: string)
 37 |         https://en.wikibooks.org/wiki/FFMPEG_An_Intermediate_Guide/image_sequence
 38 |         ffmpeg -i frame-%03d.png -c:v mpeg4 -maxrate 5M video.mp4
 39 | 
 40 |     "Always be minifying"
 41 | 
 42 |     - In other words, the most recently rendered tile is always between 2x and 4x the viewport size.
 43 |     - Magnifying produces pixelation or blurriness
 44 |     - Evaluating noise in real time causes peninsulas to morph into islands, etc.
 45 |     - We get free AA because we're supersampling
 46 |     - If the tile were always bigger than the viewport, we can do fun things with distance fields.
 47 | 
 48 |     Strategy:
 49 |     - Window is 960x540, Viewport is 960x960 BaseTile (L_f32) and CurrentTile (L_f32) are both 3840x3840.
 50 |     - Initial Viewport is 0.375,0.375 through 0.625, 0.625
 51 |     - Two floating-point tiles: BaseTile (low freq only) and CurrentTile (BaseTile + 3 layers).
 52 |     - When zooming, as soon as minification hits the 2x boundary (i.e. when vp extent is >= 0.5)
 53 |         - Re-render the CurrentTile (but with only 1 additional layer) at full res using the current vp
 54 |         - Normalize CurrentTile pixel values to [-1,+1] but do not offset (0 should not move).
 55 |         - Copy CurrentTile to BaseTile.
 56 |         - Add 3 noise layers to CurrentTile.
 57 |         - Reset the Viewport to 0.375,0.375 through 0.625, 0.625
 58 | 
 59 |     According to wikipedia, Mandelbrot is an "escape-time" fractal whereas Brownian surfaces are "random
 60 |     fractals" because they are generated via stochastic rules. Arbitrary precision libraries like BLAH
 61 |     can help.
 62 | 
 63 |     Binary Ninja or github cutter
 64 | 
 65 | # PROMOTE INTO AN ACTUAL IMAGE LIBRARY?
 66 | 
 67 |     Tagline: "Friendly Image Library in Nim"
 68 | 
 69 |     Grid
 70 |         float => float32, int => int32
 71 |         use mapIt and applyIt
 72 |         private width & height in favor of getters
 73 |         maybe even private data?
 74 |         templatize the pattern of looping over rows, cols, and having "x y row col", e.g.
 75 |             with pixels(grid):
 76 |                 pixel = pixel + 1.0f - x + y / float(row)
 77 |         addBorder (default argument of 1)
 78 |         blitFrom
 79 | 
 80 |     Image
 81 |         pillow suite of things
 82 |         colorspace: linear / srgb
 83 |         toDataString takes CLAMP or NORMALIZE
 84 | 
 85 |     Canvas
 86 |         port from Skia
 87 |         Wrote program that creates diagram showing the relationship between
 88 |             Grid / Image / Canvas
 89 | 
 90 |     automate tests
 91 |         keep it simple, just check in the PNG files and diff them with a simple nim program
 92 | 
 93 |     open source & nimble
 94 |         "The top level of the package source directory should contain at most one module, "
 95 |         "named 'cairo.nim', but a file named 'cairowin32.nim' was found. This will be an error "
 96 |         "in the future."
 97 | 
 98 |     docs
 99 |         look in history for "Remove docs" and revert
100 |         brew install mkdocs
101 |         pip install mkdocs-material
102 |         mkdocs serve
103 |         mkdocs build -d /tmp/docs
104 |         git checkout gh-pages; rsync /tmp/docs ./
105 | 
106 |     see also
107 |         https://nimble.directory/search?query=graphics
108 |         http://rnduja.github.io/2015/10/21/scientific-nim/
109 |         https://narimiran.github.io/2018/05/10/python-numpy-nim.html
110 |         https://github.com/stavenko/nim-glm
111 |         https://github.com/unicredit/neo
112 |         Canvas
113 |             Model from Skia classes
114 |             https://github.com/memononen/nanosvg
115 |             https://nimble.directory/pkg/nimagg (the AGG library, hand ported from C, seems nice)
116 |             https://nimble.directory/pkg/suffer (looks like a personal project; draws 2D shapes with pure nim and depends on a few C libraries)
117 | 
118 | -->
119 | 


--------------------------------------------------------------------------------
/src/image.nim:
--------------------------------------------------------------------------------
  1 | import grid
  2 | import strformat
  3 | import vector
  4 | 
  5 | type
  6 |     Image* = ref object
  7 |         width*, height*: int
  8 |         red*: Grid
  9 |         grn*: Grid
 10 |         blu*: Grid
 11 |         alp*: Grid
 12 |     ColorGradient* = ref object
 13 |         red*: array[256, float32]
 14 |         grn*: array[256, float32]
 15 |         blu*: array[256, float32]
 16 |         alp*: array[256, float32]
 17 | 
 18 | proc addOverlay*(a, b: Image): Image =
 19 |     new(result)
 20 |     assert(a.width == b.width and a.height == b.height)
 21 |     let invalp = 1 - b.alp
 22 |     result.red = a.red * invalp
 23 |     result.grn = a.grn * invalp
 24 |     result.blu = a.blu * invalp
 25 |     result.alp = a.alp * invalp
 26 |     result.red += b.red
 27 |     result.grn += b.grn
 28 |     result.blu += b.blu
 29 |     result.alp += b.alp
 30 |     result.width = a.width
 31 |     result.height = a.height
 32 | 
 33 | proc newImageFromLuminance*(grid: Grid): Image =
 34 |     new(result)
 35 |     result.red = newGrid(grid)
 36 |     result.grn = newGrid(grid)
 37 |     result.blu = newGrid(grid)
 38 |     result.alp = newGrid(grid.width, grid.height, 1.0f)
 39 |     result.width = grid.width
 40 |     result.height = grid.height
 41 | 
 42 | # TODO: rename to newImageFromBGRA8
 43 | proc newImageFromDataString*(data: string; width, height: int): Image =
 44 |     new(result)
 45 |     result.red = newGrid(width, height)
 46 |     result.grn = newGrid(width, height)
 47 |     result.blu = newGrid(width, height)
 48 |     result.alp = newGrid(width, height)
 49 |     result.width = width
 50 |     result.height = height
 51 |     var i = 0; var j = 0
 52 |     for row in 0..<result.height:
 53 |         for col in 0..<result.width:
 54 |             result.red.data[j] = float(data[i + 2]) / 255
 55 |             result.grn.data[j] = float(data[i + 1]) / 255
 56 |             result.blu.data[j] = float(data[i + 0]) / 255
 57 |             result.alp.data[j] = float(data[i + 3]) / 255
 58 |             i += 4
 59 |             inc j
 60 | 
 61 | # Exports the floating-point data by clamping to [0, 1] and scaling to 255.
 62 | # TODO: rename to toRGBA8
 63 | proc toDataString*(img: Image): string =
 64 |     result = newString(img.width * img.height * 4)
 65 |     var i = 0; var j = 0
 66 |     for row in 0..<img.height:
 67 |         for col in 0..<img.width:
 68 |             result[i + 0] = char((img.red.data[j] * 255).clamp(0, 255))
 69 |             result[i + 1] = char((img.grn.data[j] * 255).clamp(0, 255))
 70 |             result[i + 2] = char((img.blu.data[j] * 255).clamp(0, 255))
 71 |             result[i + 3] = char((img.alp.data[j] * 255).clamp(0, 255))
 72 |             i += 4
 73 |             inc j
 74 | 
 75 | # Given 0xRRGGBB, returns a 3-tuple in [0,1]
 76 | proc colorToFloat3(color: int): Vec3f =
 77 |     let
 78 |         red = float32((color shr 16) and 0xff)
 79 |         grn = float32((color shr 08) and 0xff)
 80 |         blu = float32((color shr 00) and 0xff)
 81 |     (red / 255.0f, grn / 255.0f, blu / 255.0f)
 82 | 
 83 | # TODO: linearize, then delinearize; see
 84 | # https://github.com/prideout/heman/blob/master/src/color.c
 85 | proc newColorGradient*(colors: seq[int]): ColorGradient =
 86 |     new(result)
 87 |     assert (colors.len() mod 2) == 0
 88 |     assert colors.len() > 2
 89 |     assert colors[0] == 0
 90 |     assert colors[colors.len() - 2] == 255
 91 |     var i = 0
 92 |     while i < colors.len() - 2:
 93 |         let
 94 |             currval = colors[i]
 95 |             nextval = colors[i + 2]
 96 |             currrgb = colorToFloat3(colors[i + 1])
 97 |             nextrgb = colorToFloat3(colors[i + 3])
 98 |         assert(currval >= 0 and currval < 256)
 99 |         assert(nextval >= 0 and nextval < 256)
100 |         assert(nextval >= currval)
101 |         let
102 |             ncols = nextval - currval
103 |             del = (nextrgb - currrgb) / float(ncols)
104 |         var col = currrgb
105 |         for j in currval..nextval:
106 |             result.red[j] = col.x
107 |             result.grn[j] = col.y
108 |             result.blu[j] = col.z
109 |             col += del
110 |         i += 2
111 | 
112 | proc applyColorGradient*(image: Image, colors: ColorGradient): void =
113 |     var j = 0
114 |     for row in 0..<image.height:
115 |         for col in 0..<image.width:
116 |             let
117 |                 red = (image.red.data[j] * 255).clamp(0, 255)
118 |                 grn = (image.grn.data[j] * 255).clamp(0, 255)
119 |                 blu = (image.blu.data[j] * 255).clamp(0, 255)
120 |             image.red.data[j] = colors.red[int(red)]
121 |             image.grn.data[j] = colors.grn[int(grn)]
122 |             image.blu.data[j] = colors.blu[int(blu)]
123 |             inc j
124 | 
125 | proc hstack*(a: Image, b: varargs[Image]): Image =
126 |     var
127 |         reds = newSeq[Grid]()
128 |         grns = newSeq[Grid]()
129 |         blus = newSeq[Grid]()
130 |         alps = newSeq[Grid]()
131 |     for img in items(b):
132 |         reds.add(img.red)
133 |         grns.add(img.grn)
134 |         blus.add(img.blu)
135 |         alps.add(img.alp)
136 |     new(result)
137 |     result.red = hstack(a.red, reds)
138 |     result.grn = hstack(a.grn, grns)
139 |     result.blu = hstack(a.blu, blus)
140 |     result.alp = hstack(a.alp, alps)
141 |     result.width = result.red.width
142 |     result.height = result.red.height
143 | 
144 | proc drawGrid*(image: Image; ncols, nrows: int): void =
145 |     image.red = image.red.drawGrid(ncols, nrows)
146 |     image.grn = image.grn.drawGrid(ncols, nrows)
147 |     image.blu = image.blu.drawGrid(ncols, nrows)
148 |     image.alp = image.alp.drawGrid(ncols, nrows, 1)
149 |     inc image.width
150 |     inc image.height
151 | 
152 | proc crop*(image: Image, vp: Viewport): Image =
153 |     new(result)
154 |     let
155 |         left = int(vp.left * float32(image.width))
156 |         right = int(vp.right * float32(image.width))
157 |         top = int(vp.top * float32(image.height))
158 |         bottom = int(vp.bottom * float32(image.height))
159 |     result.red = image.red.crop(left, top, right, bottom)
160 |     result.grn = image.grn.crop(left, top, right, bottom)
161 |     result.blu = image.blu.crop(left, top, right, bottom)
162 |     result.alp = image.alp.crop(left, top, right, bottom)
163 |     result.width = result.red.width
164 |     result.height = result.red.height
165 | 


--------------------------------------------------------------------------------
/src/filter.nim:
--------------------------------------------------------------------------------
  1 | import math
  2 | import image
  3 | import grid
  4 | 
  5 | type Filter* = object
  6 |     radius*: float32
  7 |     function*: proc (x: float32): float32
  8 | 
  9 | let FilterHermite* = Filter(radius: 1, function: proc (x: float32): float32 =
 10 |     if x >= 1.0: return 0
 11 |     2 * x * x * x - 3 * x * x + 1)
 12 | 
 13 | let FilterTriangle* = Filter(radius: 1, function: proc (x: float32): float32 =
 14 |     if x >= 1.0: return 0
 15 |     1.0 - x)
 16 | 
 17 | let FilterGaussian* = Filter(radius: 2, function: proc (x: float32): float32 =
 18 |     const scale = 1.0f / sqrt(0.5f * math.PI)
 19 |     if x >= 2.0: return 0
 20 |     exp(-2 * x * x) * scale)
 21 | 
 22 | # Computes an average value over a viewport in [0,+1] and accounts for pixel squares that are
 23 | # only partially covered by the viewport.
 24 | proc computeAverage*(g: Grid; left, top, right, bottom: float32): float32 =
 25 |     let
 26 |         x0 = left * float32(g.width)
 27 |         y0 = top * float32(g.height)
 28 |         x1 = right * float32(g.width)
 29 |         y1 = bottom * float32(g.height)
 30 |         inner_col0 = int(ceil(x0)).max(0)
 31 |         inner_row0 = int(ceil(y0)).max(0)
 32 |         inner_col1 = int(floor(x1)).min(g.width) - 1
 33 |         inner_row1 = int(floor(y1)).min(g.height) - 1
 34 |         outer_col0 = int(floor(x0)).max(0)
 35 |         outer_row0 = int(floor(y0)).max(0)
 36 |         outer_col1 = int(ceil(x1)).min(g.width) - 1
 37 |         outer_row1 = int(ceil(y1)).min(g.height) - 1
 38 |     var
 39 |         area = 0.0f
 40 |         total = 0.0f
 41 |     # First add up the pixel squares that lie completely inside the viewport.
 42 |     for col in inner_col0..inner_col1:
 43 |         for row in inner_row0..inner_row1:
 44 |             area += 1.0
 45 |             total += g.getPixel(col, row)
 46 |     # Determine the amount of fractional overhang on all 4 sides.
 47 |     let
 48 |         w = float32(inner_col0) - x0
 49 |         e = x1 - float32(outer_col1)
 50 |         n = float32(inner_row0) - y0
 51 |         s = y1 - float32(outer_row1)
 52 |     # Left column of pixels with fractional coverage.
 53 |     if w > 0:
 54 |         for row in inner_row0..inner_row1:
 55 |             area += w; total += w * g.getPixel(outer_col0, row)
 56 |     # Right column of pixels with fractional coverage.
 57 |     if e > 0:
 58 |         for row in inner_row0..inner_row1:
 59 |             area += e; total += e * g.getPixel(outer_col1, row)
 60 |     # Top row of pixels with fractional coverage.
 61 |     if n > 0:
 62 |         for col in inner_col0..inner_col1:
 63 |             area += n; total += n * g.getPixel(col, outer_row0)
 64 |     # Bottom row of pixels with fractional coverage.
 65 |     if s > 0:
 66 |         for col in inner_col0..inner_col1:
 67 |             area += s; total += s * g.getPixel(col, outer_row1)
 68 |     # Northwest corner.
 69 |     if w > 0 and n > 0:
 70 |         area += w * n; total += w * n * g.getPixel(outer_col0, outer_row0)
 71 |     # Southwest corner.
 72 |     if w > 0 and s > 0:
 73 |         area += w * s; total += w * s * g.getPixel(outer_col0, outer_row1)
 74 |     # Northeast corner.
 75 |     if e > 0 and n > 0:
 76 |         area += e * n; total += e * n * g.getPixel(outer_col1, outer_row0)
 77 |     # Southeast corner.
 78 |     if s > 0 and e > 0:
 79 |         area += s * e; total += s * e * g.getPixel(outer_col1, outer_row1)
 80 |     total / area
 81 | 
 82 | # Resamples the given image using a technique sometimes called "pixel mixing".
 83 | # This is the same as a classic box filter when magnifying or minifying by a multiple of 2.
 84 | proc resizeBoxFilter*(g: Grid, width, height: int): Grid =
 85 |     result = newGrid(width, height)
 86 |     let dx = 1.0f / float32(width)
 87 |     let dy = 1.0f / float32(height)
 88 |     var x = 0.0f
 89 |     var y = 0.0f
 90 |     var i = 0
 91 |     for row in 0..<height:
 92 |         x = 0
 93 |         for col in 0..<width:
 94 |             let v = g.computeAverage(x, y, x + dx, y + dy)
 95 |             result.data[i] = v
 96 |             inc i
 97 |             x += dx
 98 |         y += dy
 99 | 
100 | # Resizes an image by choosing nearest pixels from the source image (does no filtering whatsoever).
101 | proc resizeNearestFilter*(g: Grid, width, height: int): Grid =
102 |     result = newGrid(width, height)
103 |     let dx = 1.0f / float32(width)
104 |     let dy = 1.0f / float32(height)
105 |     var x = 0.5f * dx
106 |     var y = 0.5f * dy
107 |     var i = 0
108 |     for row in 0..<height:
109 |         x = 0
110 |         for col in 0..<width:
111 |             result.data[i] = g.sampleNearest(x, y)
112 |             inc i
113 |             x += dx
114 |         y += dy
115 | 
116 | # Resizes an image by choosing nearest pixels from the source image (does no filtering whatsoever).
117 | proc resizeNearestFilter*(g: Grid, scale: int): Grid =
118 |     g.resizeNearestFilter(g.width * scale, g.height * scale)
119 | 
120 | # Regardless of filter type, any resizing operation executes a Multiply-Accumulate (Macc) more
121 | # than anything else. This can be described as:
122 | #       targetRow[targetColumn] += sourceRow[sourceColumn] * filterWeight
123 | # The operands that can be cached from row to row are the two indices and the weight.
124 | type MaccOp = tuple[targetColumn: int, sourceColumn: int, filterWeight: float32]
125 | 
126 | # Generates a list of MACC instructions that results in the transformation of a sequence of length
127 | # "sourceLen" into a sequence of length "targetLen" using the specified filter function.
128 | proc computeMaccOps(targetLen, sourceLen: int; filter: Filter): seq[MaccOp] =
129 |     result = newSeq[MaccOp]()
130 |     let
131 |         targetDelta = 1 / float32(targetLen)
132 |         sourceDelta = 1 / float32(sourceLen)
133 |         minifying = targetLen < sourceLen
134 |         filterExtent = if minifying: targetDelta else: sourceDelta
135 |         filterDomain = float32(if minifying: targetLen else: sourceLen)
136 |     var x = targetDelta / 2
137 |     for targetIndex in 0..<targetLen:
138 |         let
139 |             minx = x - filter.radius * filterExtent
140 |             maxx = x + filter.radius * filterExtent
141 |             minsi = int(minx * float32(sourceLen))
142 |             maxsi = int(ceil(maxx * float32(sourceLen)))
143 |         var
144 |             nsamples = 0
145 |             weightSum = 0.0f
146 |         for si in minsi..maxsi:
147 |             if si < 0 or si >= sourceLen: continue
148 |             let
149 |                 sx = (0.5 + float32(si)) * sourceDelta
150 |                 t = filterDomain * abs(sx - x)
151 |                 weight = filter.function(t)
152 |             if weight != 0:
153 |                 result.add (targetIndex, si, weight)
154 |                 weightSum += weight
155 |                 inc nsamples
156 |         if weightSum > 0:
157 |             while nsamples > 0:
158 |                 result[result.len() - nsamples].filterWeight /= weightSum
159 |                 dec nsamples
160 |         x += targetDelta
161 | 
162 | # Resizes an image with the given filter.
163 | proc resize*(source: Grid, width, height: int, filter: Filter): Grid =
164 |     # First resize horizontally.
165 |     let horizontal = newGrid(width, source.height)
166 |     var ops = computeMaccOps(width, source.width, filter)
167 |     for ty in 0..<horizontal.height:
168 |         for tx, sx, weight in ops.items():
169 |             horizontal.addPixel(tx, ty, source.getPixel(sx, ty) * weight)
170 |     # Next resize vertically.
171 |     result = newGrid(width, height)
172 |     ops = computeMaccOps(height, source.height, filter)
173 |     var transpose = newSeq[float32](source.height)
174 |     for tx in 0..<width:
175 |         for y in 0..<source.height:
176 |             transpose[y] = horizontal.getPixel(tx, y)
177 |         for ty, sy, weight in ops.items():
178 |             result.addPixel(tx, ty, transpose[sy] * weight)
179 | 
180 | proc resize*(image: Image, width, height: int, filter: Filter): void =
181 |     image.width = width
182 |     image.height = height
183 |     image.red = image.red.resize(width, height, filter)
184 |     image.grn = image.grn.resize(width, height, filter)
185 |     image.blu = image.blu.resize(width, height, filter)
186 |     image.alp = image.alp.resize(width, height, filter)
187 | 


--------------------------------------------------------------------------------
/tests/zoom.nim:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env nim c -d:release --boundChecks:off --verbosity:0 --run
  2 | 
  3 | import math
  4 | import nile
  5 | import os
  6 | import strformat
  7 | 
  8 | const NFRAMES = 20
  9 | const VIEWPORT_RESOLUTION = 320
 10 | const TILE_RESOLUTION = 1024
 11 | const SEED = 3
 12 | const ZOOM_SPEED = 0.025
 13 | const SMOOTH_PALETTE = @[
 14 |     000, 0x001070 , # Dark Blue
 15 |     126, 0x2C5A7C , # Light Blue
 16 |     127, 0xE0F0A0 , # Yellow
 17 |     129, 0x5D943C , # Green
 18 |     140, 0x5D943C , # Green
 19 |     160, 0x606011 , # Brown
 20 |     255, 0xFFFFFF ] # White
 21 | 
 22 | type Map = ref object
 23 |     resolution: int
 24 |     seed: int
 25 | 
 26 | type Tile = ref object
 27 |     distance*: Grid
 28 |     mask*: Grid
 29 |     noise*: Grid
 30 |     elevation*: Grid
 31 |     index*: Vec3ii
 32 |     offset*: float
 33 |     map: Map
 34 |     children: array[4, Tile]
 35 | 
 36 | proc generateFalloff(size: int, view: Viewport): Grid =
 37 |     result = newGrid(size, size)
 38 |     let
 39 |         dx = (view.right - view.left) / float32(size)
 40 |         dy = (view.bottom - view.top) / float32(size)
 41 |     var y = view.top
 42 |     var i = 0
 43 |     for row in 0..<size:
 44 |         var x = view.left
 45 |         for col in 0..<size:
 46 |             let
 47 |                 t = len((x,y) - (0.5f, 0.5f))
 48 |                 v = FilterHermite.function(t)
 49 |             result.data[i] = v * v * v
 50 |             inc i
 51 |             x += dx
 52 |         y += dy
 53 | 
 54 | proc generateRootTile(resolution, seed: int): Tile =
 55 |     let
 56 |         size = resolution
 57 |         view = ENTIRE
 58 |         falloff = generateFalloff(size, view)
 59 |         vp0 = view * 4.0f
 60 |         vp1 = vp0 * 2.0f
 61 |         vp2 = vp1 * 2.0f
 62 |         vp3 = vp2 * 2.0f
 63 |         vp4 = vp3 * 2.0f
 64 |     new(result)
 65 |     result.index = (0'i64, 0'i64, 0'i64)
 66 |     result.map = new Map
 67 |     result.map.resolution = resolution
 68 |     result.map.seed = seed
 69 |     var g = generateGradientNoise(seed, size, size, vp0)
 70 |     g *= 2.0f
 71 |     g += generateGradientNoise(seed + 1, size, size, vp1)
 72 |     g *= 2.0f
 73 |     g += generateGradientNoise(seed + 2, size, size, vp2)
 74 |     g *= 2.0f
 75 |     g += generateGradientNoise(seed + 3, size, size, vp3)
 76 |     g *= 2.0f
 77 |     g += generateGradientNoise(seed + 4, size, size, vp4)
 78 |     g /= 16
 79 |     g += falloff / 2
 80 |     g *= falloff
 81 |     result.noise = g * 1.0
 82 |     result.mask = g.step(0.1)
 83 |     g = createSdf(result.mask)
 84 |     result.offset = 0.0
 85 |     var
 86 |         lower = min(g)
 87 |         upper = max(g)
 88 |     result.distance = (g - lower) / (upper - lower)
 89 |     result.offset = (result.offset - lower) / (upper - lower)
 90 |     result.elevation = result.distance - result.offset
 91 |     result.elevation -= 0.5 * result.elevation * result.noise
 92 |     result.elevation += 0.5
 93 | 
 94 | proc generateChild(child: Tile, parent: Tile, subview: Viewport): void =
 95 |     let
 96 |         map = child.map
 97 |         zoom = child.index.z
 98 |         seed = map.seed + int(zoom)
 99 |         size = map.resolution
100 |         fsize = float(size)
101 |         left = int(subview.left * fsize)
102 |         top = int(subview.top * fsize)
103 |         right = int(subview.right * fsize)
104 |         bottom = int(subview.bottom * fsize)
105 |     child.offset = parent.offset
106 |     child.mask = parent.mask.crop(left, top, right, bottom).resize(size, size, FilterGaussian)
107 |     let g = createSdf(child.mask)
108 |     let (lower, upper) = (min(g), max(g))
109 |     child.distance = (g - lower) / (upper - lower)
110 |     child.offset = (0.0 - lower) / (upper - lower)
111 |     child.noise = 0.0125 * generateGradientNoise(seed, size, size, ENTIRE * 16.0)
112 |     child.distance += child.noise
113 |     child.mask = child.distance.step(child.offset)
114 |     child.elevation = child.distance - child.offset
115 |     child.elevation -= 5.0 * child.elevation * child.noise # <== This doesn't really do much.
116 |     child.elevation += 0.5
117 | 
118 | proc generateChild(parent: Tile, index: Vec3ii): Tile =
119 |     assert(index.z == parent.index.z + 1)
120 |     let
121 |         west = parent.index.x * 2
122 |         east = west + 1
123 |         north = parent.index.y * 2
124 |         south = north + 1
125 |     result = new Tile
126 |     result.index = index
127 |     result.map = parent.map
128 |     if index.x == west and index.y == north:
129 |         parent.children[0] = result
130 |         generateChild(result, parent, (0.0f, 0.0f, 0.5f, 0.5f))
131 |     elif index.x == east and index.y == north:
132 |         parent.children[1] = result
133 |         generateChild(result, parent, (0.5f, 0.0f, 1.0f, 0.5f))
134 |     elif index.x == west and index.y == south:
135 |         parent.children[2] = result
136 |         generateChild(result, parent, (0.0f, 0.5f, 0.5f, 1.0f))
137 |     elif index.x == east and index.y == south:
138 |         parent.children[3] = result
139 |         generateChild(result, parent, (0.5f, 0.5f, 1.0f, 1.0f))
140 |     else:
141 |         echo fmt"Cannot generate child {index.x:03} {index.y:03} {index.z:03}"
142 |         assert(false)
143 | 
144 | # Show the given PNG image if the platform supports it.
145 | proc showPNG(fname: string): void =
146 |     if 0 == execShellCmd fmt"which -s imgcat":
147 |         discard execShellCmd fmt"imgcat {fname}"
148 |     else:
149 |         echo fmt"Generated {fname}"
150 | 
151 | # Find a quadrant that contains coastline and a good distribution of landmass vs water.
152 | proc chooseChild(parent: Tile): Vec3ii =
153 |     var results = newSeq[Vec3ii]()
154 |     let
155 |         x = parent.index.x * 2
156 |         y = parent.index.y * 2
157 |         z = parent.index.z + 1
158 |         el = parent.elevation
159 |         (w2, h2) = (el.width, el.height)
160 |         (w1, h1) = (int(w2 / 2), int(h2 / 2))
161 |     var bestAverage = 100.0f
162 |     let isBest = proc(l, t, r, b: int): bool =
163 |         let
164 |             quadrant = el.crop(l, t, r, b)
165 |             (lo, hi) = (quadrant.min(), quadrant.max())
166 |             avg = abs(quadrant.avg() - 0.5)
167 |             hasCoast = sgn(lo - 0.5) != sgn(hi - 0.5)
168 |         if avg < bestAverage and hasCoast:
169 |             bestAverage = avg
170 |             return true
171 |         return false
172 |     if isBest(00, 00, w1, h1): results.add (x+0, y+0, z)
173 |     if isBest(w1, 00, w2, h1): results.add (x+1, y+0, z)
174 |     if isBest(00, h1, w1, h2): results.add (x+0, y+1, z)
175 |     if isBest(w1, h1, w2, h2): results.add (x+1, y+1, z)
176 |     if results.len() == 0:
177 |         echo "No coastline."
178 |         quit()
179 |     results[results.len() - 1]
180 | 
181 | let gradient = newColorGradient(SMOOTH_PALETTE)
182 | 
183 | # Convert an entire grid-of-floats into a colorful PNG image.
184 | proc renderEntire(tile: Tile, fname: string): void =
185 |     var image = newImageFromLuminance(tile.elevation)
186 |     image.applyColorGradient(gradient)
187 |     image.resize(VIEWPORT_RESOLUTION, VIEWPORT_RESOLUTION, FilterHermite)
188 |     image.savePNG(fname)
189 |     showPNG(fname)
190 | 
191 | # Convert a portion of a grid-of-floats into a colorful PNG image.
192 | proc renderPartial(tile: Tile, fname: string, vp: Viewport): void =
193 |     var image = newImageFromLuminance(tile.elevation).crop(vp)
194 |     image.applyColorGradient(gradient)
195 |     image.resize(VIEWPORT_RESOLUTION, VIEWPORT_RESOLUTION, FilterHermite)
196 |     image.savePNG(fname)
197 | 
198 | # Lerp the viewport from an entire tile to one of its quadrants.
199 | proc smoothZoom(tile: Tile, targetIndex: Vec3ii, frame: var int): int =
200 |     var vp: Viewport = (0.0f, 0.0f, 1.0f, 1.0f)
201 |     let
202 |         amt = ZOOM_SPEED
203 |         (parent, child) = (tile.index, targetIndex)
204 |         nw = child.x == parent.x * 2 + 0 and child.y == parent.y * 2 + 0
205 |         ne = child.x == parent.x * 2 + 1 and child.y == parent.y * 2 + 0
206 |         sw = child.x == parent.x * 2 + 0 and child.y == parent.y * 2 + 1
207 |         se = child.x == parent.x * 2 + 1 and child.y == parent.y * 2 + 1
208 |     while (vp.right - vp.left) > 0.5:
209 |         if nw: vp.right -= amt; vp.bottom -= amt
210 |         if ne: vp.left += amt; vp.bottom -= amt
211 |         if sw: vp.right -= amt; vp.top += amt
212 |         if se: vp.left += amt; vp.top += amt
213 |         renderPartial(tile, fmt"frame-{frame:03}.png", vp)
214 |         inc frame
215 |     return frame
216 | 
217 | if isMainModule:
218 |     var tile = generateRootTile(TILE_RESOLUTION, SEED)
219 |     echo tile.index
220 |     var frame = 0
221 |     renderEntire(tile, fmt"frame-{frame:03}.png")
222 |     inc frame
223 |     for zoom in 1..NFRAMES:
224 |         let childIndex = chooseChild(tile)
225 |         echo childIndex
226 |         frame = smoothZoom(tile, childIndex, frame)
227 |         tile = generateChild(tile, childIndex)
228 |         renderEntire(tile, fmt"frame-{frame:03}.png")
229 |         inc frame
230 | 
231 |     discard execShellCmd "ffmpeg -i frame-%03d.png -c:v mpeg4 -vb 150M video.mp4"
232 |     discard execShellCmd "rm frame*.png"
233 | 


--------------------------------------------------------------------------------
/src/grid.nim:
--------------------------------------------------------------------------------
  1 | import math
  2 | import sequtils
  3 | import strutils
  4 | import vector
  5 | 
  6 | ## Simple two-dimensional image with floating-point luminance data.
  7 | ## Values are stored in row-major (scanline) order, but coordinates and dimensions use
  8 | ## X Y notation (i.e. columns ⨯ rows) with 0,0 being the top-left.
  9 | type
 10 |     Grid* = ref object
 11 |       data*: seq[float32]
 12 |       width*, height*: int
 13 | 
 14 | # Creates a grid full of zeros.
 15 | proc newGrid*(width, height: int): Grid =
 16 |     new(result)
 17 |     result.data = newSeq[float32](width * height)
 18 |     result.width = width
 19 |     result.height = height
 20 | 
 21 | # Creates a grid filled with the given value.
 22 | proc newGrid*(width, height: int, value: float32): Grid =
 23 |     new(result)
 24 |     result.data = repeat(value, width * height)
 25 |     result.width = width
 26 |     result.height = height
 27 | 
 28 | # Clone a grid.
 29 | proc newGrid*(grid: Grid): Grid =
 30 |     new(result)
 31 |     result.data = grid.data
 32 |     result.width = grid.width
 33 |     result.height = grid.height
 34 | 
 35 | # Consumes a multiline string composed of 0's and 1's.
 36 | proc newGrid*(pattern: string): Grid =
 37 |     new(result)
 38 |     for iter in tokenize(pattern):
 39 |         if not iter.isSep:
 40 |             inc result.height
 41 |             let ncols = iter.token.len()
 42 |             if result.width == 0:
 43 |                 result.width = ncols
 44 |             elif result.width != ncols: 
 45 |                 doAssert false
 46 |     result.data = newSeq[float32](result.width * result.height)
 47 |     var n = 0
 48 |     for iter in tokenize(pattern):
 49 |         if not iter.isSep:
 50 |             for c in iter.token:
 51 |                 result.data[n] = float32(ord(c) - ord('0'))
 52 |                 inc n
 53 | 
 54 | # Returns a new grid with the results of op applied to every value.
 55 | proc map*(g: Grid, op: proc (x: float32): float32): Grid =
 56 |     new(result)
 57 |     result.data = map(g.data, op)
 58 |     result.width = g.width
 59 |     result.height = g.height
 60 | 
 61 | # Convenience template around the map proc to reduce typing.
 62 | template mapIt*(g: Grid, op: untyped): Grid =
 63 |     new(result)
 64 |     result.data = newSeq[float32](g.data.len)
 65 |     result.width = g.width
 66 |     result.height = g.height
 67 |     var i = 0
 68 |     let t = g.data
 69 |     for it {.inject.} in t:
 70 |         result.data[i] = op
 71 |         inc i
 72 |     result
 73 | 
 74 | # Applies op to every item in g modifying it directly.
 75 | proc apply*(g:Grid, op: proc (x: var float32): void): void = g.data.apply(op)
 76 | 
 77 | # Addition.
 78 | proc `+`*(k: float32, g: Grid): Grid = g.map(proc(f: float32): float32 = k + f)
 79 | proc `+`*(g: Grid, k: float32): Grid = k + g    
 80 | proc `+=`*(g: Grid, k: float32): void = g.apply(proc(f: var float32): void = f += k)
 81 | proc `+=`*(a: Grid, b: Grid): void =
 82 |     assert(a.data.len() == b.data.len())
 83 |     for i in 0..<a.data.len(): a.data[i] += b.data[i]
 84 | proc `-=`*(a: Grid, b: Grid): void =
 85 |     assert(a.data.len() == b.data.len())
 86 |     for i in 0..<a.data.len(): a.data[i] -= b.data[i]
 87 |     
 88 | # Multiplication (component wise).
 89 | proc `*`*(g: Grid, k: float32): Grid = g.map(proc(f: float32): float32 = f * k)
 90 | proc `*`*(k: float32, g: Grid): Grid = g.map(proc(f: float32): float32 = f * k)
 91 | proc `*=`*(g: Grid, k: float32): void = g.apply(proc(f: var float32): void = f *= k)
 92 | proc `*=`*(a: Grid, b: Grid): void =
 93 |     assert(a.data.len() == b.data.len())
 94 |     for i in 0..<a.data.len(): a.data[i] *= b.data[i]
 95 | 
 96 | # Misc other math ops.
 97 | proc `/`*(g: Grid, k: float32): Grid = g * (1.0f / k)
 98 | proc `/=`*(g: Grid, k: float32): void = g *= (1.0f / k)    
 99 | proc `-`*(k: float32, g: Grid): Grid = g.map(proc(f: float32): float32 = k - f)
100 | proc `-`*(g: Grid, k: float32): Grid = g + (-k)
101 | proc `-=`*(g: Grid, k: float32): void = g.apply(proc(f: var float32): void = f += k)
102 | 
103 | # Do not use zip in the following procs, it seems inefficient.
104 | proc `+`*(a: Grid, b: Grid): Grid =
105 |     assert(a.width == b.width and a.height == b.height)
106 |     new(result)
107 |     result.data = newSeq[float32](a.data.len())
108 |     for i in 0..<a.data.len(): result.data[i] = a.data[i] + b.data[i]
109 |     result.width = a.width
110 |     result.height = a.height
111 | 
112 | proc `-`*(a: Grid, b: Grid): Grid =
113 |     assert(a.width == b.width and a.height == b.height)
114 |     new(result)
115 |     result.data = newSeq[float32](a.data.len())
116 |     for i in 0..<a.data.len(): result.data[i] = a.data[i] - b.data[i]
117 |     result.width = a.width
118 |     result.height = a.height
119 | 
120 | proc `*`*(a: Grid, b: Grid): Grid =
121 |     assert(a.width == b.width and a.height == b.height)
122 |     new(result)
123 |     result.data = newSeq[float32](a.data.len())
124 |     for i in 0..<a.data.len(): result.data[i] = a.data[i] * b.data[i]
125 |     result.width = a.width
126 |     result.height = a.height
127 | 
128 | proc step*(g: Grid, k: float32): Grid = g.map(proc(f: float32): float32 =
129 |     if f <= k: 0 else: 1)
130 | 
131 | # Finds the smallest value in the entire grid.
132 | proc min*(g: Grid): float32 = foldl(g.data, min(a, b), high(float32))
133 | 
134 | # Finds the largest value in the entire grid.
135 | proc max*(g: Grid): float32 = foldl(g.data, max(a, b), low(float32))
136 | 
137 | # Finds the sum of all pixels.
138 | proc sum*(g: Grid): float32 = foldl(g.data, a + b, 0.0f)
139 | 
140 | proc avg*(g: Grid): float32 = sum(g) / float32(g.data.len())
141 | 
142 | # Sets the pixel value at the given column and row.
143 | proc setPixel*(g: Grid, x, y: int, k: float32 = 1): void =
144 |     assert(x >= 0 and x < g.width and y >= 0 and y < g.height)
145 |     g.data[y * g.width + x] = k
146 | 
147 | # Adds the given value into the texel
148 | proc addPixel*(g: Grid, x, y: int, k: float32 = 1): void =
149 |     assert(x >= 0 and x < g.width and y >= 0 and y < g.height)
150 |     g.data[y * g.width + x] += k
151 |     
152 | # Gets the pixel value at the given column and row.
153 | proc getPixel*(g: Grid, x, y: int): float32 =
154 |     assert(x >= 0 and x < g.width and y >= 0 and y < g.height)
155 |     g.data[y * g.width + x]
156 |     
157 | # Takes floating point coordinates in [0,+1] and returns the nearest pixel value.
158 | proc sampleNearest*(g: Grid, x, y: float32): float32 =
159 |     let col = max(0, min(int(float32(g.width) * x), g.width - 1))
160 |     let row = max(0, min(int(float32(g.height) * y), g.height - 1))
161 |     g.data[row * g.width + col]
162 | 
163 | # Copies a region of pixels from the source grid.
164 | proc blitFrom*(dst: Grid, src: Grid; dstx, dsty: int; left, top, right, bottom: int): void =
165 |     var dstrow = dsty;
166 |     for srcrow in top..<bottom:
167 |         var dstcol = dstx;
168 |         for srccol in left..<right:
169 |             dst.setPixel(dstcol, dstrow, src.getPixel(srccol, srcrow))
170 |             inc dstcol
171 |         inc dstrow
172 | 
173 | # Draws single-pixel gridlines such that "ncols ⨯ nrows" cells have borders.
174 | # Increases the width and height of the grid by 1 pixel.
175 | proc drawGrid*(g: Grid; ncols, nrows: int; value: float32 = 0): Grid =
176 |     result = newGrid(g.width + 1, g.height + 1)
177 |     result.blitFrom(g, 0, 0, 0, 0, g.width, g.height)
178 |     for row in 0..<nrows:
179 |         let y = int(row * g.height / nrows)
180 |         for x in 0..<g.width:
181 |             result.setPixel(x, y, value)
182 |     for col in 0..<ncols:
183 |         let x = int(col * g.width / ncols)
184 |         for y in 0..<g.height:
185 |             result.setPixel(x, y, value)
186 |     if value != 0:
187 |         let y = result.height - 1
188 |         for x in 0..<result.width:
189 |             result.setPixel(x, y, value)
190 |         let x = result.width - 1
191 |         for y in 0..<result.height:
192 |             result.setPixel(x, y, value)
193 |     
194 | # Create an image from a rectangular region.
195 | proc crop*(source: Grid, left, top, right, bottom: int): Grid =
196 |     result = newGrid(right - left, bottom - top)
197 |     var i = 0
198 |     for row in 0..<result.height:
199 |         for col in 0..<result.width:
200 |             result.data[i] = source.getPixel(left + col, top + row)
201 |             inc i
202 | 
203 | # Stacks arrays horizontally (column wise).
204 | proc hstack*(a: Grid, b: varargs[Grid]): Grid =
205 |     var width = a.width
206 |     for g in items(b):
207 |         width += g.width
208 |     result = newGrid(width, a.height)
209 |     for row in 0..<result.height:
210 |         for col in 0..<a.width:
211 |             result.setPixel(col, row, a.getPixel(col, row))
212 |     for row in 0..<result.height:
213 |         var tcol = a.width
214 |         for g in items(b):
215 |             doAssert(a.height == g.height)
216 |             for scol in 0..<g.width:
217 |                 result.setPixel(tcol, row, g.getPixel(scol, row))
218 |                 inc tcol
219 | 
220 | # Stacks arrays vertically (row wise).
221 | proc vstack*(a: Grid, b: varargs[Grid]): Grid =
222 |     var height = a.height
223 |     for g in items(b):
224 |         height += g.height
225 |     result = newGrid(a.width, height)
226 |     for col in 0..<result.width:
227 |         for row in 0..<a.height:
228 |             result.setPixel(col, row, a.getPixel(col, row))
229 |     for col in 0..<result.width:
230 |         var trow = a.height
231 |         for g in items(b):
232 |             doAssert(a.width == g.width)
233 |             for srow in 0..<g.height:
234 |                 result.setPixel(col, trow, g.getPixel(col, srow))
235 |                 inc trow
236 | 
237 | # Exports the floating-point data by clamping to [0, 1] and scaling to 255.
238 | proc toDataString*(g: Grid): string =
239 |     let npixels = g.width * g.height
240 |     result = newString(npixels)
241 |     for i in 0..<npixels:
242 |         let v = g.data[i].clamp(0, 1)
243 |         result[i] = chr(int(v * 255))
244 | 


--------------------------------------------------------------------------------