geom-grid.stanza

;; See license.txt for details about licensing.

defpackage geom/grid :
  import core
  import math
  import collections
  import utils/rnd
  import geom/vec
  import geom/box
  import geom/pixels
  import geom/triangle
  import geom/polygon
  import geom/bounded
  import gfx/gl
  import gfx/glu
  import gfx/drawing

public val trace? = false

protected extern malloc: long -> ptr<?>
protected extern free: ptr<?> -> int

extern todos_fab: () -> ptr<?>
extern todos_del: (ptr<?>) -> int
extern todos_clear: (ptr<?>) -> int
extern todos_elt: (ptr<?>, int, ptr<int>) -> int
extern todos_len: (ptr<?>) -> int

public lostanza deftype Todos :
  value: ptr<?>

public lostanza defn Todos () -> ref<Todos> :
  val res = call-c todos_fab()
  return new Todos{res}

public lostanza defn del (v:ref<Todos>) -> ref<False> :
  call-c todos_del(v.value)
  return false

public lostanza defn clear (v:ref<Todos>) -> ref<False> :
  call-c todos_clear(v.value)
  return false

val pt = Vec3i(0, 0, 0)

public lostanza defn get (v:ref<Todos>, i:ref<Int>) -> ref<Vec3i> :
  call-c todos_elt(v.value, i.value, addr!(pt.x))
  return Vec3i(x(pt), y(pt), z(pt))

public lostanza defn length (v:ref<Todos>) -> ref<Int> :
  val res = call-c todos_len(v.value)
  return new Int{res}

extern grid_fill: (int, int, int, ptr<byte>, byte) -> int
extern grid_fill_range: (int, int, int, int, int, int, int, int, int, ptr<byte>, byte) -> int
extern grid_equals: (int, int, int, ptr<byte>, ptr<byte>) -> int
;; extern grid_invert_off: (int, int, int, int, int, int, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_invert: (int, int, int, ptr<byte>, ptr<byte>) -> int
extern grid_copy_off: (int, int, int, int, int, int, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_copy: (int, int, int, ptr<byte>, ptr<byte>) -> int
extern grid_union_off: (int, int, int, int, int, int, ptr<byte>, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_union: (int, int, int, ptr<byte>, ptr<byte>, ptr<byte>) -> int
;; extern grid_intersect_off: (int, int, int, int, int, int, ptr<byte>, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_intersect: (int, int, int, ptr<byte>, ptr<byte>, ptr<byte>) -> int
extern grid_convolve: (int, int, int, ptr<byte>, int, int, int, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_convolve_around: (int, int, int, ptr<byte>, int, int, int, ptr<byte>, int, int, int, ptr<byte>) -> int
extern grid_dilate: (int, int, int, ptr<byte>, ptr<byte>) -> int
extern grid_find_ones: (int, int, int, ptr<byte>, ptr<?>) -> int
extern grid_ones_box: (int, int, int, ptr<byte>, ptr<int>, ptr<int>) -> int
extern grid_count_ones: (int, int, int, ptr<byte>) -> int
extern grid_hash: (int, int, int, ptr<byte>) -> int

public lostanza defn fill (dst:ref<Grid>, v:ref<Byte>) -> ref<False> :
  call-c grid_fill(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value, addr!(data(dst).data), v.value)
  return false

public lostanza defn fill (dst:ref<Grid>, v:ref<Byte>, bbox:ref<Box3i>) -> ref<False> :
  call-c grid_fill_range(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                         x(lo(bbox)).value, y(lo(bbox)).value, z(lo(bbox)).value,
                         x(hi(bbox)).value, y(hi(bbox)).value, z(hi(bbox)).value,
                         addr!(data(dst).data), v.value)
  return false

lostanza defn grid-equals? (a:ref<Grid>, b:ref<Grid>) -> ref<True|False> :
  val res = call-c grid_equals(n-cols(a).value, n-rows(a).value, n-lays(a).value, addr!(data(a).data), addr!(data(b).data))
  if res == 0 :
    return false
  else :
    return true

public lostanza defn invert (dst:ref<Grid>, src:ref<Grid>) -> ref<False> :
  call-c grid_invert(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value, addr!(data(dst).data), addr!(data(src).data))
  return false

;; lostanza defn invert (dst:ref<Grid>, src:ref<Grid>, off:ref<Vec3i>) -> ref<False> :
;;   call-c grid_invert_off(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
;;                          x(off).value, y(off).value, z(off).value, addr!(data(dst).data),
;;                          n-cols(src).value, n-rows(src).value, n-lays(src).value, addr!(data(src).data))
;;   return false

public lostanza defn copy (dst:ref<Grid>, src:ref<Grid>) -> ref<False> :
  call-c grid_copy(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value, addr!(data(dst).data), addr!(data(src).data))
  return false

public lostanza defn copy (dst:ref<Grid>, src:ref<Grid>, off:ref<Vec3i>) -> ref<False> :
  call-c grid_copy_off(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                       x(off).value, y(off).value, z(off).value, addr!(data(dst).data),
                       n-cols(src).value, n-rows(src).value, n-lays(src).value, addr!(data(src).data))
  return false

public lostanza defn union (dst:ref<Grid>, s0:ref<Grid>, s1:ref<Grid>) -> ref<False> :
  call-c grid_union(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                    addr!(data(dst).data), addr!(data(s0).data), addr!(data(s1).data))
  return false

public lostanza defn union (dst:ref<Grid>, s0:ref<Grid>, s1:ref<Grid>, off:ref<Vec3i>) -> ref<False> :
  call-c grid_union_off(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                        x(off).value, y(off).value, z(off).value,
                        addr!(data(dst).data), addr!(data(s0).data),
                        n-cols(s1).value, n-rows(s1).value, n-lays(s1).value, addr!(data(s1).data))
  return false

public lostanza defn intersect (dst:ref<Grid>, s0:ref<Grid>, s1:ref<Grid>) -> ref<False> :
  call-c grid_intersect(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                        addr!(data(dst).data), addr!(data(s0).data), addr!(data(s1).data))
  return false

;; lostanza defn intersect (dst:ref<Grid>, s0:ref<Grid>, s1:ref<Grid>, off:ref<Vec3i>) -> ref<False> :
;;   call-c grid_intersect_off(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
;;                             x(off).value, y(off).value, z(off).value,
;;                             addr!(data(dst).data), addr!(data(s0).data),
;;                             n-cols(s1).value, n-rows(s1).value, n-lays(s1).value, addr!(data(s1).data))
;;   return false

lostanza defn do-convolve-around (dst:ref<Grid>, src:ref<Grid>, a-default:ref<Byte>, mask:ref<Grid>) -> ref<False> :
  call-c grid_convolve_around(
     n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
     addr!(data(dst).data),
     n-cols(src).value, n-rows(src).value, n-lays(src).value,
     addr!(data(src).data),
     n-cols(mask).value, n-rows(mask).value, n-lays(mask).value,
     addr!(data(mask).data))
  return false

lostanza defn do-convolve (dst:ref<Grid>, src:ref<Grid>, a-default:ref<Byte>, mask:ref<Grid>) -> ref<False> :
  call-c grid_convolve(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                       addr!(data(dst).data),
                       n-cols(src).value, n-rows(src).value, n-lays(src).value,
                       addr!(data(src).data),
                       n-cols(mask).value, n-rows(mask).value, n-lays(mask).value,
                       addr!(data(mask).data))
  return false

public lostanza defn dilate (dst:ref<Grid>, src:ref<Grid>) -> ref<False> :
  call-c grid_dilate(n-cols(dst).value, n-rows(dst).value, n-lays(dst).value,
                     addr!(data(dst).data),
                     addr!(data(src).data))
  return false

public lostanza defn find-ones (g:ref<Grid>, todos:ref<Todos>) -> ref<False> :
  call-c grid_find_ones(n-cols(g).value, n-rows(g).value, n-lays(g).value, addr!(data(g).data), todos.value)
  return false

lostanza defmethod hash (g:ref<Grid>) -> ref<Int> :
  val res = call-c grid_hash(n-cols(g).value, n-rows(g).value, n-lays(g).value, addr!(data(g).data))
  return new Int{res}

public defstruct Grid <: Equalable & Hashable :
  idims: Vec3i
  dim: Double
  ;; ibbox: Box3i
  ;; dim: Double
  ;; bbox: Box
  ;; pts: Array<Vec3>
  data: ByteArray

public defn ibbox (g:Grid) -> Box3i :
  Box3i(Vec3i(0, 0, 0), idims(g) - Vec3i(1, 1, 1))

defn transform (f-d:Vec3i -> Vec3i, f-p:Vec3i -> Vec3i, g:Grid) -> Grid:
  val res = Grid(f-d(idims(g)), dim(g))
  for off in indices(idims(g)) do :
    set-value(res, f-p(off), get-value(g, off))
  res

public defn rotate (r:Int, g:Grid) -> Grid:
  val d = idims(g)
  switch {r == _} :
    90 :   transform(fn (p) : Vec3i(y(p), x(p), 1), fn (p) : Vec3i(y(d) - y(p) - 1, x(p)),            g)
    180 :  transform(fn (p) : p,                  fn (p) : Vec3i(x(d) - x(p) - 1, y(d) - y(p) - 1), g)
    270 :  transform(fn (p) : Vec3i(y(p), x(p), 1), fn (p) : Vec3i(y(p),            x(d) - x(p) - 1), g)
    else : g

public defn dump (dst:Grid) :
  for k in 0 to n-lays(dst) do :
    for j in (n-rows(dst) - 1) through 0 by -1 do :
      for i in 0 to n-cols(dst) do :
        ;; println-all(["[" i "," j "," k "] = " get-value(dst, i, j, k)])
        ;; print(get-value(dst, i, j, k))
        val v = get-value(dst, i, j, k)
        val c = '.' when v == to-byte(0) else ('*' when v == to-byte(1) else '?')
        print(c)
      println("")
      
defn n-cols (grid:Grid) -> Int : x(idims(grid))
defn n-rows (grid:Grid) -> Int : y(idims(grid))
defn n-lays (grid:Grid) -> Int : z(idims(grid))

defn to-double (v:Vec3i) -> Vec3 :
  Vec3(to-double(x(v)), to-double(y(v)), to-double(z(v)))

;; defn cdims (grid:Grid) -> Vec3 :
;;   dims(bbox(grid)) / to-double(idims(grid))

defn index (g:Grid, i:Int, j:Int, k:Int) -> Int :
  (k * n-cols(g) * n-rows(g)) + j * n-cols(g) + i

;; defn pt (g:Grid, off:Int) -> Vec3i :
;;   val area = (n-cols(g) * n-rows(g))
;;   val b = off % area
;;   Vec3i(b % n-cols(g), b / n-cols(g), off / area) 
;; 
;; defn get-pt (g:Grid, i:Int, j:Int, k:Int) -> Vec3 :
;;   pts(g)[index(g, i, j, k)]
;; 
;; defn get-pt (g:Grid, pos:Vec3i) -> Vec3 :
;;   get-pt(g, x(pos), y(pos), z(pos))

public defn get-value (g:Grid, i:Int, j:Int, k:Int) -> Byte :
  data(g)[index(g, i, j, k)]

public defn get-value (g:Grid, pos:Vec3i) -> Byte :
  get-value(g, x(pos), y(pos), z(pos))

public defn legal? (dims:Vec3i, i:Int, j:Int, k:Int) -> True|False :
  i >= 0 and i < x(dims) and
  j >= 0 and j < y(dims) and
  k >= 0 and k < z(dims)

public defn legal? (g:Grid, i:Int, j:Int, k:Int) -> True|False :
  legal?(idims(g), i, j, k)

public defn legal? (g:Grid, pos:Vec3i) -> True|False :
  legal?(g, x(pos), y(pos), z(pos))

public defn legal? (g:Grid, new-bbox:Box3i) -> True|False :
  legal?(g, lo(new-bbox)) and legal?(g, hi(new-bbox))

public defn fits? (dims:Vec3i, i:Int, j:Int, k:Int) -> True|False :
  i >= 0 and i <= x(dims) and
  j >= 0 and j <= y(dims) and
  k >= 0 and k <= z(dims)

public defn fits? (outside:Vec3i, inside:Vec3i) -> True|False :
  fits?(outside, x(inside), y(inside), z(inside))

public defn get-value (g:Grid, pos:Vec3i, default:Byte) -> Byte :
  get-value(g, x(pos), y(pos), z(pos)) when legal?(g, pos) else default
    
public defn set-value (g:Grid, i:Int, j:Int, k:Int, v:Byte) :
  if legal?(g, i, j, k) :
    data(g)[index(g, i, j, k)] = v

public defn set-value (g:Grid, pos:Vec3i, v:Byte) :
  if legal?(g, pos) :
    set-value(g, x(pos), y(pos), z(pos), v)

public var grid-allocated:Int = 0

public defn Grid (idims:Vec3i, dim:Double) -> Grid :
  grid-allocated = grid-allocated + x(idims) * y(idims) * z(idims)
  ;; println("  SIZE %_ = %_ ALLOC %_" % [idims, x(idims) * y(idims) * z(idims), allocated])
  val cells = ByteArray(x(idims) * y(idims) * z(idims), to-byte(0))
  Grid(idims, dim, cells)

public defn Grid (g:Grid) -> Grid :
  Grid(idims(g), dim(g))

public defn indices (grid:Grid) : indices(idims(grid))
  
defmethod print (o:OutputStream, g:Grid) :
  for k in 0 to n-lays(g) do :
    for j in 0 to n-rows(g) do :
      for i in 0 to n-cols(g) do :
        print-all([get-value(g, i, j, k) " "])
      println("")

defmethod equal? (a:Grid, b:Grid) -> True|False :
  idims(a) == idims(b) and grid-equals?(a, b)

;;     var same? = true
;;     for pos in indices(a) do :
;;       same? = same? and (get-value(a, pos) == get-value(b, pos))
;;     same?

;; defn points (idims:Vec3i, bbox:Box) -> Array<Vec3> :
;;   val pts = Array<Vec3>(x(idims) * y(idims) * z(idims))
;;   val cdims = dims(bbox) / to-double(idims) 
;;   for k in 0 to z(idims) do :
;;     val zc = z(lo(bbox)) + to-double(k) * z(cdims)
;;     for j in 0 to y(idims) do :
;;       val yc = y(lo(bbox)) + (to-double(j) + 0.5f) * y(cdims)
;;       for i in 0 to x(idims) do :
;;         val xc = x(lo(bbox)) + (to-double(i) + 0.5f) * x(cdims)
;;         val idx = (k * x(idims) * y(idims)) + j * x(idims) + i
;;         pts[idx] = Vec3(xc, yc, zc)
;;   pts
;; 
;; defn pt-of (pt:Vec3i, idims:Vec3i, bbox:Box) -> Vec3 :
;;   val cdims = dims(bbox) / to-double(idims) 
;;   val zc = z(lo(bbox)) + to-double(z(pt)) * z(cdims)
;;   val yc = y(lo(bbox)) + (to-double(y(pt)) + 0.5f) * y(cdims)
;;   val xc = x(lo(bbox)) + (to-double(x(pt)) + 0.5f) * x(cdims)
;;   val res = Vec3(xc, yc, zc)
;;   ;; println-all(["PT-OF " pt " IDIMS " idims " BBOX " bbox " CDIMS " cdims " RES " res])
;;   res 
;; 
;; defn pt-of (pt:Vec3i, cells:Grid) -> Vec3 :
;;   pt-of(pt, idims(cells), bbox(cells))  

public defn pt-of (g:Grid, idx:Vec3i) -> Vec2 :
  ;; xy(dim(g) * (to-vec3(idx) + Vec3(0.5, 0.5, 0.0) - (0.5 * to-vec3(idims(g)))))
  xy(dim(g) * (to-vec3(idx) + 0.5 * to-vec3(xyz(1) - idims(g))))

public defn ctr-pt (g:Grid) -> Vec2 :
  xy(dim(g) * 0.5 * to-vec3(idims(g)))

val straight-deltas2 = [Vec3i(-1, 0, 0), Vec3i(1, 0, 0), Vec3i(0, -1, 0), Vec3i(0, 1, 0)]
val straight-deltas = to-tuple $ cat(straight-deltas2, [Vec3i(0, 0, -1), Vec3i(0, 0, 1)])
val diagonal-deltas = [Vec3i(-1, -1, 0), Vec3i(-1, 1, 0), Vec3i(1, -1, 0), Vec3i(1, 1, 0)]
val all-deltas = to-tuple $ cat(straight-deltas, diagonal-deltas)

val all-deltas2 = to-tuple $ cat(straight-deltas2, diagonal-deltas)

public defn do-render-values (cells:Grid, c:Vec3) :
  gl-push-attrib(GL-LINE-BIT | GL-CURRENT-BIT)
  gl-push-matrix()
  val dim = dim(cells)
  val dims = idims(cells)
  val ext = 0.5 * dim * to-vec3(dims)
  gl-push-matrix()
  val off = -1.0 * ext + xyz(xy(Vec3-fill(0.5 * dim)))
  gl-translate(x(off), y(off), 0.0)
  for pos in indices(dims) do :
    val v = get-value(cells, pos)
    if v == to-byte(1) :
      gl-push-matrix()
      val p = dim * to-vec3(pos)
      gl-translate(x(p), y(p), 0.0)
      gl-scale(0.95, 0.95, 0.95)
      val cv = c ;; (to-double $ v) * c
      gl-color(x(cv), y(cv), z(cv), (to-double $ v))
      draw-quad(dim, dim)
      gl-pop-matrix()
  gl-pop-matrix()
  gl-color(1.0, 1.0, 1.0, 1.0)
  draw-rect(to-double(x(dims)) * dim, to-double(y(dims)) * dim)
  ;; for pos in indices(dims) do :
  ;;   gl-push-matrix()
  ;;   val p = to-vec3(pos)
  ;;   gl-translate(x(p), y(p), 0.0)
  ;;   draw-rect(dim, dim)
  ;;   gl-pop-matrix()
  gl-pop-matrix()
  gl-pop-attrib()

public defn render-values (cells:Grid, c:Vec3) :
  gl-push-matrix()
  val dims = idims(cells)
  val ext = 0.5 * to-vec3(dims)
  val fac = max(x(ext), y(ext))
  gl-scale(0.9 / fac, 0.9 / fac, 1.0)
  do-render-values(cells, c)
  gl-pop-matrix()

public defn render-values (cells:Grid) : render-values(cells, Vec3(1.0, 0.0, 0.0))

public defn find-limits (dst:Grid) -> Box3i :
  var l = hi(ibbox(dst))
  var h = lo(ibbox(dst))
  for pos in indices(dst) do :
    val v = get-value(dst, pos)
    if v > to-byte(0) :
      l = min(pos, l)
      h = max(pos, h)
      ;; set-value(dst, pos, to-byte $ 0)
  Box3i(l, h)

;; defn fill (dst:Grid, x:Byte) :
;;   for pos in indices(dst) do :
;;     set-value(dst, pos, x)
;; 
;; defn fill (dst:Grid, x:Byte, bounds:Box3i) :
;;   for pos in indices(bounds) do :
;;     set-value(dst, pos, x)
;; 
;; defn copy (dst:Grid, src:Grid, off:Vec3i) :
;;   for pos in indices(src) do :
;;     set-value(dst, pos + off, get-value(src, pos))
;; 
;; defn invert (dst:Grid, src:Grid, off:Vec3i) :
;;   for pos in indices(src) do :
;;     set-value(dst, pos + off, to-byte(1) - get-value(src, pos))
;; 
;; defn union (dst:Grid, src0:Grid, src1:Grid, off:Vec3i) :
;;   for pos in indices(src1) do :
;;     set-value(dst, pos + off, get-value(src0, pos + off, to-byte $ 0) | get-value(src1, pos))
;; 
;; defn union (dst:Grid, src0:Grid, src1:Grid) : union(dst, src0, src1, Vec3i(0, 0, 0))
;; 
;; defn intersect (dst:Grid, src0:Grid, src1:Grid, off:Vec3i) :
;;   for pos in indices(src1) do :
;;     set-value(dst, pos + off, get-value(src0, pos + off, to-byte $ 0) & get-value(src1, pos))
;; 
;; defn intersect (dst:Grid, src0:Grid, src1:Grid) : intersect(dst, src0, src1, Vec3i(0, 0, 0))

public defn dilate (dst:Grid, src:Grid, off:Vec3i) :
  fill(dst, to-byte $ 0)
  for delta in all-deltas2 do :
    union(dst, dst, src, off + delta)

defn any-intersection? (a:Grid, a-default:Byte, b:Grid, off:Vec3i) -> True|False :
  ;; println-all(["ANY OFF " off])
  for pos in indices(b) any? :
    val av = get-value(a, pos + off, a-default)
    val bv = get-value(b, pos)
    println-all(["SG " (pos + off) " -> " av " " pos " " bv " = " (av & bv)])
    ;; (get-value(a, pos + off, a-default) & get-value(b, pos)) == to-byte(1)
    (av & bv) == to-byte(1)

public defn convolve (d:Grid, a:Grid, a-default:Byte, b:Grid) :
  if trace?: println-all(["CONVOLVE DIMS-D " idims(d) " DIMS-B " idims(b) " DIMS " idims(d) - idims(b)])
  if trace?: println-all(["A"])
  if trace?: dump(a)
  if trace?: println-all(["B"])
  if trace?: dump(b)
  do-convolve(d, a, a-default, b)
  ;; for pos in indices(xy(idims(d) - idims(b)) + Vec3i(0, 0, 1)) do :
  ;;   set-value(d, pos, to-byte(1 when any-intersection?(a, a-default, b, pos - xy(idims(b))) else 0))
  if trace?: println-all(["D"])
  if trace?: dump(d)

public defn convolve-around (d:Grid, a:Grid, a-default:Byte, b:Grid) :
  if trace?: println-all(["CONVOLVE DIMS-D " idims(d) " DIMS-B " idims(b) " DIMS " idims(d) - idims(b)])
  if trace?: println-all(["A"])
  if trace?: dump(a)
  if trace?: println-all(["B"])
  if trace?: dump(b)
  do-convolve-around(d, a, a-default, b)
  ;; for pos in indices(xy(idims(d) - idims(b)) + Vec3i(0, 0, 1)) do :
  ;;   set-value(d, pos, to-byte(1 when any-intersection?(a, a-default, b, pos - xy(idims(b))) else 0))
  if trace?: println-all(["D"])
  if trace?: dump(d)

;; defn true-indices (legal:Grid) -> Seq<Vec3i> :
;;   generate<Vec3i> :
;;     for off in indices(legal) do :
;;       yield(off) when get-value(legal, off) == to-byte(1)
  
defn default-box3i () : Box3i(Vec3i(0, 0, 0), Vec3i(0, 0, 0))

public lostanza defn find-ones-box (g:ref<Grid>) -> ref<Box3i> :
  val lo:ptr<int> = call-c malloc(3 * sizeof(int))
  val hi:ptr<int> = call-c malloc(3 * sizeof(int))
  call-c grid_ones_box(n-cols(g).value, n-rows(g).value, n-lays(g).value, addr!(data(g).data), lo, hi)
  val res = Box3i(Vec3i(new Int{lo[0]}, new Int{lo[1]}, new Int{lo[2]}),
                  Vec3i(new Int{hi[0]}, new Int{hi[1]}, new Int{hi[2]}))
  call-c free(lo)
  call-c free(hi)
  return res

public lostanza defn count-ones (g:ref<Grid>) -> ref<Int> :
  val res = call-c grid_count_ones(n-cols(g).value, n-rows(g).value, n-lays(g).value, addr!(data(g).data))
  return new Int{res}

public defn true-indices (legal:Grid, trues:Todos) -> Seq<Vec3i> :
  find-ones(legal, trues)
  generate<Vec3i> :
    for i in 0 to length(trues) do :
      yield(trues[i])
  
public defn rnd-grid (box3i:Box3i) -> Grid :
  val idims = Vec3i(rndi(x(lo(box3i)), x(hi(box3i))), rndi(y(lo(box3i)), y(hi(box3i))), 1)
  println-all(["IDIMS " idims])
  val image = Grid(idims, 0.0)
  for pos in indices(idims) do :
    set-value(image, pos, to-byte(1 when (rndd(0.0, 1.0) > 0.6) else 0))
  println-all(["I"])
  dump(image)
  image

public defn to-grid (vals:Tuple<Tuple<Int>>) -> Grid :
  val idims = Vec3i(length(vals[0]), length(vals), 1)
  val image = Grid(idims, 0.0)
  for pos in indices(idims) do :
    set-value(image, pos, to-byte $ vals[y(pos)][x(pos)])
  ;; println-all(["I"])
  ;; dump(image)
  image

public defn to-grid (pix:Pixels) -> Grid :
  val image = Grid(idims(pix) - Vec3i(2, 2, 0), dim(pix))
  for pos in indices(idims(image)) do :
    set-value(image, pos, pix[pos + Vec3i(1, 1, 0)])
  image

public defn to-pixels (grid:Grid) -> Pixels :
  val image = Pixels(idims(grid), dim(grid), ByteArray(x(idims(grid)) * y(idims(grid))))
  for pos in indices(idims(image)) do :
    image[pos] = get-value(grid, pos)
  image

public defn bounds (g:Grid) :
  Box2(pt-of(g, Vec3i(0, 0, 0)), pt-of(g, idims(g) - Vec3i(1, 1, 0)))

public defn idx-of (dim:Double, idims:Vec3i, p:Vec3) :
  val ext = xy(-0.5 * dim * to-vec3(idims))
  to-vec3i(xyz(round((xy(p) - ext) / dim)))

public defn idx-of (g:Grid, p:Vec3) : idx-of(dim(g), idims(g), p)

public defn scan (g:Grid, t:Triangle) :
  val box = bounds(t)
  val boxi = Box3i(idx-of(g, xyz(lo(box))) - xyz(1), idx-of(g, xyz(hi(box))) + xyz(1))
  ;; println("TRIANGLE %_ BOX %_ BOXI %_ STOCK-BOX %_" % [ t box boxi bounds(g) ])
  ;; val fac = 0.5 * dim(g)
  for j in y(lo(boxi)) through y(hi(boxi)) do :
    for i in x(lo(boxi)) through x(hi(boxi)) do :
      val pi = Vec2i(i, j)
      val p  = pt-of(g, xyz(pi))
      if inside?(t, p) :
        set-value(g, i, j, 0, to-byte(1))
;;      for dx in -1 through 1 by 2 do :
;;        for dy in -1 through 1 by 2 do :
;;          val ip = p + fac * Vec2(to-double(dx), to-double(dy))
;;          if inside?(t, ip) :
;;            set-value(g, i, j, 0, to-byte(1))

public defn scan (g:Grid, p:Polygon) :
  ;; println("SCAN %_ grid bounds %_ polygon bounds %_" % [p bounds(g) bounds(p)])
  for tri in triangles(p) do :
    scan(g, tri)

public defn Grid (box:Box3, dim:Double) -> Grid :
  val fdims = xy(dims $ box)
  val rdims = to-vec2i $ round $ (fdims / dim + Vec2(2.0, 2.0)) ; estimate dims
  val rgrid = Grid(Vec3i(x(rdims), y(rdims), 1), dim)
  val pts = corners(box)
  val idims = dims $ reduce(union, seq({ Box2i(xy(idx-of(rgrid, xyz(_)))) }, pts)) ; calc real dims
  Grid(Vec3i(x(idims) + 2, y(idims) + 2, 1), dim)

public defn Grid (poly:Polygon, dim:Double) -> Grid :
  val res = Grid(bounds(poly), dim)
  scan(res, poly)
  res