
import algorithm, bumpy, chroma, pixie/images, print,
    sequtils, vmath, benchy

import pixie, pixie/paths {.all.}


printColors = false

proc intersects*(a, b: Segment, at: var Vec2): bool {.inline.} =
  ## Checks if the a segment intersects b segment.
  ## If it returns true, at will have point of intersection
  let
    s1 = a.to - a.at
    s2 = b.to - b.at
    denominator = (-s2.x * s1.y + s1.x * s2.y)
    s = (-s1.y * (a.at.x - b.at.x) + s1.x * (a.at.y - b.at.y)) / denominator
    t = (s2.x * (a.at.y - b.at.y) - s2.y * (a.at.x - b.at.x)) / denominator

  if s > 0 and s < 1 and t > 0 and t < 1:
    at = a.at + (t * s1)
    return true

proc pixelCover(a0, b0: Vec2): float32 =
  ## Returns the amount of area a given segment sweeps to the right
  ## in a [0,0 to 1,1] box.
  var
    a = a0
    b = b0
    aI: Vec2
    bI: Vec2
    area: float32 = 0.0

  # # Sort A on top.
  # if a.y > b.y:
  #   let tmp = a
  #   a = b
  #   b = tmp

  # if (b.y < 0 or a.y > 1) or # Above or bellow, no effect.
  #   (a.x >= 1 and b.x >= 1) or # To the right, no effect.
  #   (a.y == b.y): # Horizontal line, no effect.
  #   return 0

  if (a.x < 0 and b.x < 0) or # Both to the left.
    (a.x == b.x): # Vertical line
    # Area of the rectangle:
    return (1 - clamp(a.x, 0, 1)) * (min(b.y, 1) - max(a.y, 0))

  else:
    # y = mm*x + bb
    let
      mm: float32 = (b.y - a.y) / (b.x - a.x)
      bb: float32 = a.y - mm * a.x

    if a.x >= 0 and a.x <= 1 and a.y >= 0 and a.y <= 1:
      # A is in pixel bounds.
      aI = a
    else:
      aI = vec2((0 - bb) / mm, 0)
      if aI.x < 0:
        let y = mm * 0 + bb
        # Area of the extra rectangle.
        area += (min(bb, 1) - max(a.y, 0)).clamp(0, 1)
        aI = vec2(0, y.clamp(0, 1))
      elif aI.x > 1:
        let y = mm * 1 + bb
        aI = vec2(1, y.clamp(0, 1))

    if b.x >= 0 and b.x <= 1 and b.y >= 0 and b.y <= 1:
      # B is in pixel bounds.
      bI = b
    else:
      bI = vec2((1 - bb) / mm, 1)
      if bI.x < 0:
        let y = mm * 0 + bb
        # Area of the extra rectangle.
        area += (min(b.y, 1) - max(bb, 0)).clamp(0, 1)
        bI = vec2(0, y.clamp(0, 1))
      elif bI.x > 1:
        let y = mm * 1 + bb
        bI = vec2(1, y.clamp(0, 1))

  area += ((1 - aI.x) + (1 - bI.x)) / 2 * (bI.y - aI.y)
  return area

proc intersectsInner*(a, b: Segment, at: var Vec2): bool {.inline.} =
  ## Checks if the a segment intersects b segment.
  ## If it returns true, at will have point of intersection
  let
    s1 = a.to - a.at
    s2 = b.to - b.at
    denominator = (-s2.x * s1.y + s1.x * s2.y)
    s = (-s1.y * (a.at.x - b.at.x) + s1.x * (a.at.y - b.at.y)) / denominator
    t = (s2.x * (a.at.y - b.at.y) - s2.y * (a.at.x - b.at.x)) / denominator

  if s > 0 and s < 1 and t >= 0 and t <= 1:
    at = a.at + (t * s1)
    return true

type

  Trapezoid = object
    nw, ne, se, sw: Vec2

  Line = object
    #m, x, b: float32
    atx, tox: float32

proc toLine(s: Segment): Line =
  var line = Line()
  # y = mx + b
  line.atx = s.at.x
  line.tox = s.to.x
  # line.m = (s.at.y - s.to.y) / (s.at.x - s.to.x)
  # line.b = s.at.y - line.m * s.at.x
  return line

proc roundBy*(v: Vec2, n: float32): Vec2 {.inline.} =
  result.x = sign(v.x) * round(abs(v.x) / n) * n
  result.y = sign(v.y) * round(abs(v.y) / n) * n

proc fillPath2(mask: Mask, p: Path) =

  var polygons = p.commandsToShapes()

  const q = 1/256.0

  # Creates segment q, quantize and remove horizontal lines.
  var segments1: seq[Segment]
  for shape in polygons:
    for s in shape.segments:
      var s = s
      s.at = s.at.roundBy(q)
      s.to = s.to.roundBy(q)
      if s.at.y != s.to.y:
        if s.at.y > s.to.y:
          # make sure segments always are at.y higher
          swap(s.at, s.to)
        segments1.add(s)
  segments1.sort(proc(a, b: Segment): int = cmp(a.at.y, b.at.y))

  # Compute cutLines
  var
    cutLines: seq[float32]
    last = segments1[0].at.y
    bottom = segments1[0].to.y
  cutLines.add(last)
  for s in segments1:
    if s.at.y != last:
      last = s.at.y
      cutLines.add(last)
    if bottom < s.to.y:
      bottom = s.to.y
  cutLines.add(bottom)
  #print cutLines

  var
    sweeps = newSeq[seq[Line]](cutLines.len - 1) # dont add bottom cutLine
    lastSeg = 0
  for i, sweep in sweeps.mpairs:
    #print "sweep", i, cutLines[i]
    while segments1[lastSeg].at.y == cutLines[i]:
      let s = segments1[lastSeg]
      #print s
      if s.to.y != cutLines[i + 1]:
        #print "needs cut?"
        quit()
      sweep.add(toLine(segments1[lastSeg]))
      inc lastSeg
      if lastSeg >= segments1.len:
        # Sort the last sweep by X
        break
    # Sort the sweep by X
    sweep.sort proc(a, b: Line): int =
      result = cmp(a.atx, b.atx)
      if result == 0:
        result = cmp(a.tox, b.tox)

  #print sweeps

  proc fillCoverage(y: int, currCutLine: int, sweep: seq[Line]) =

    let
      sweepHeight = cutLines[currCutLine + 1] - cutLines[currCutLine]
      yFracTop = (y.float32 - cutLines[currCutLine]) / sweepHeight
      yFracBottom = (y.float32 + 1 - cutLines[currCutLine]) / sweepHeight
    var i = 0
    while i < sweep.len:
      let
        nwX = mix(sweep[i+0].atx, sweep[i+0].tox, yFracTop)
        neX = mix(sweep[i+1].atx, sweep[i+1].tox, yFracTop)

        swX = mix(sweep[i+0].atx, sweep[i+0].tox, yFracBottom)
        seX = mix(sweep[i+1].atx, sweep[i+1].tox, yFracBottom)

        minWi = min(nwX, swX).int
        maxWi = max(nwX, swX).ceil.int

        minEi = min(neX, seX).int
        maxEi = max(neX, seX).ceil.int

      template write(x, y: int, alpha: float32) =
        let backdrop = mask.getValueUnsafe(x, y)
        mask.setValueUnsafe(x, y, backdrop + (alpha * 255).uint8)

      let
        nw = vec2(sweep[i+0].atx, cutLines[currCutLine])
        sw = vec2(sweep[i+0].tox, cutLines[currCutLine + 1])
      for x in minWi ..< maxWi:
        var area = pixelCover(nw - vec2(x.float32, y.float32), sw - vec2(x.float32, y.float32))
        write(x, y, area)

      let x = maxWi
      var midArea = pixelCover(nw - vec2(x.float32, y.float32), sw - vec2(x.float32, y.float32))
      for x in maxWi ..< minEi:
        write(x, y, midArea)

      let
        ne = vec2(sweep[i+1].atx, cutLines[currCutLine])
        se = vec2(sweep[i+1].tox, cutLines[currCutLine + 1])
      for x in minEi ..< maxEi:

        var area = midArea - pixelCover(ne - vec2(x.float32, y.float32), se - vec2(x.float32, y.float32))
        write(x, y, area)

      i += 2


    # ## x10 slower
    # for x in 0 ..< mask.width:
    #   for i, line in sweep:
    #     let
    #       segat = vec2(line.atx, cutLines[currCutLine])
    #       segto = vec2(line.tox, cutLines[currCutLine + 1])
    #     var area = pixelCover(segat - vec2(x.float32, y.float32), segto - vec2(x.float32, y.float32))
    #     if i mod 2 == 1:
    #       area = -area
    #     let backdrop = mask.getValueUnsafe(x, y)
    #     mask.setValueUnsafe(x, y, backdrop + (area * 255).uint8)


    # var i = 0
    # let
    #   sweepHeight = cutLines[currCutLine + 1] - cutLines[currCutLine]
    #   yFracTop = (y.float32 - cutLines[currCutLine]) / sweepHeight
    #   yFracBottom = (y.float32 + 1 - cutLines[currCutLine]) / sweepHeight
    # #print "cover", y, sweepHeight, yFrac
    # while i < sweep.len:
    #   #print "fill", sweep[i].at.x, "..", sweep[i+1].at.x


    #   var ay = 1.0.float32
    #   if y.float32 < cutLines[currCutLine]:
    #     let a2 = cutLines[currCutLine] - y.float32
    #     #print "cut from top", y.float, cutLines[currCutLine], a2
    #     ay *= a2
    #   if y.float32 + 1 > cutLines[currCutLine + 1]:
    #     let a2 = (y.float32 + 1) - cutLines[currCutLine + 1]
    #     #print "cut from bottom", y.float, cutLines[currCutLine], a2
    #     ay *= a2

    #   #if y == 20:
    #   # print "--", y

    #   template write(x, y: int, alpha: float32) =
    #     let backdrop = mask.getValueUnsafe(x, y)
    #     mask.setValueUnsafe(x, y, backdrop + (ay * alpha * 255).uint8)

    #   let
    #     nwX = mix(sweep[i+0].atx, sweep[i+0].tox, yFracTop)
    #     neX = mix(sweep[i+1].atx, sweep[i+1].tox, yFracTop)

    #     swX = mix(sweep[i+0].atx, sweep[i+0].tox, yFracBottom)
    #     seX = mix(sweep[i+1].atx, sweep[i+1].tox, yFracBottom)

    #     # minW = min(nwX, swX)
    #     # maxW = max(nwX, swX)
    #     # minE = min(neX, seX)
    #     # maxE = max(neX, seX)



    #   var
    #     endWAt: float32 = 0
    #     endWTo: float32 = 0
    #     endWArea: float32 = 0

    #     slopeWUp = swX < nwX
    #     slopeWAt: float32 = 0
    #     slopeWTo: float32 = 0
    #     slopeWArea: float32 = 0
    #     slopeWRate: float32 = 0

    #     transitionWAt: float32 = 0
    #     transitionWTo: float32 = 0
    #     transitionWArea: float32 = 0

    #     fillAt: float32 = 0
    #     fillTo: float32 = 0

    #     transitionEAt: float32 = 0
    #     transitionETo: float32 = 0
    #     transitionEArea: float32 = 0

    #     slopeEUp = seX < neX
    #     slopeEAt: float32 = 0
    #     slopeETo: float32 = 0
    #     slopeEArea: float32 = 0
    #     slopeERate: float32 = 0

    #     endEAt: float32 = 0
    #     endETo: float32 = 0
    #     endEArea: float32 = 0

    #   if slopeWUp:
    #     endWAt = swX.floor
    #     endWTo = swX.ceil

    #     slopeWAt = endWTo
    #     slopeWTo = nwX.floor

    #     transitionWAt = slopeWAt
    #     transitionWTo = nwX.ceil

    #     fillAt = transitionWTo

    #   else:
    #     endWAt = nwX.floor
    #     endWTo = nwX.ceil

    #     slopeWAt = endWTo
    #     slopeWTo = swX.floor

    #     transitionWAt = slopeWAt
    #     transitionWTo = swX.ceil

    #     fillAt = transitionWTo


    #   if slopeEUp:

    #     fillTo = seX.floor

    #     transitionEAt = fillTo
    #     transitionETo = seX.ceil

    #     slopeEAt = transitionETo
    #     slopeETo = neX.floor

    #     endEAt = slopeETo
    #     endETo = neX.ceil

    #   else:

    #     fillTo = neX.floor

    #     transitionEAt = fillTo
    #     transitionETo = neX.ceil

    #     slopeEAt = transitionETo
    #     slopeETo = seX.floor

    #     endEAt = slopeETo
    #     endETo = seX.ceil


    #   let
    #     segat = vec2(line.atx, cutLines[currCutLine])
    #     segto = vec2(line.tox, cutLines[currCutLine + 1])


    #     var area = pixelCover(segat - vec2(x.float32, y.float32), segto - vec2(x.float32, y.float32))
    #     if i mod 2 == 1:
    #       area = -area


    #   #print endWAt, slopeWAt, transitionWAt, fillAt, fillTo, transitionEAt, slopeEAt, endEAt

    #   # if nwX < swX:
    #   #   print nwX.int, swX.int
    #   #   for x in nwX.int ..< swX.int:
    #   #     var a = 0.5 # ((x.float32 - nwX) / (swX - nwX))
    #   #     #print a
    #   #     write(x, y, a.clamp(0, a))
    #   # else:
    #   #   for x in swX.int ..< nwX.int:
    #   #     var a = 0.5 #((x.float32 - swX) / (nwX - swX))
    #   #     #print a
    #   #     write(x, y, a.clamp(0, a))

    #   #write(wX.int, y, 1 - (wX - wX.floor))

    #   # for x in endWAt.int ..< endWTo.int:
    #   #   write(x, y, 0.1)

    #   # for x in slopeWAt.int ..< slopeWTo.int:
    #   #   write(x, y, 0.25)

    #   # for x in transitionWAt.int ..< transitionWTo.int:
    #   #   write(x, y, 0.50)

    #   for x in fillAt.int ..< fillTo.int:
    #     write(x, y, 1)

    #   # for x in transitionEAt.int ..< transitionETo.int:
    #   #   write(x, y, 0.50)

    #   # for x in slopeEAt.int ..< slopeETo.int:
    #   #   write(x, y, 0.25)

    #   # for x in endEAt.int ..< endETo.int:
    #   #   write(x, y, 0.1)

    #   # print 1 - (eX - eX.floor)
    #   # write(eX.int - 1, y, 1 - (eX - eX.floor))

    #   # if neX < seX:
    #   #   for x in neX.int ..< seX.int:
    #   #     var a = 0.5 # ((neX - x.float32) / (seX - neX))
    #   #     #print a
    #   #     write(x, y, a.clamp(0, a))
    #   # else:
    #   #   for x in seX.int ..< neX.int:
    #   #     var a = 0.5 # ((seX - x.float32) / (neX - seX))
    #   #     #print a
    #   #     write(x, y, a.clamp(0, a))

    #   i += 2

    # let quality = 5
    # for m in 0 ..< quality:
    #   let
    #     sweepHeight = cutLines[currCutLine + 1] - cutLines[currCutLine]
    #     yFrac = (y.float32 + (m.float32 / quality.float32) - cutLines[currCutLine]) / sweepHeight
    #   if yFrac < 0.0 or yFrac >= 1.0:
    #     continue
    #   var i = 0
    #   while i < sweep.len:
    #     let
    #       minXf1 = mix(sweep[i+0].at.x, sweep[i+0].to.x, yFrac)
    #       maxXf1 = mix(sweep[i+1].at.x, sweep[i+1].to.x, yFrac)
    #       minXi1 = minXf1.int
    #       maxXi1 = maxXf1.int
    #     for x in minXi1 ..< maxXi1:
    #       let backdrop = mask.getValueUnsafe(x, y)
    #       mask.setValueUnsafe(x, y, backdrop + (255 div quality).uint8)
    #       # if x == 100 and y == 165:
    #       #   print backdrop, 255 div quality
    #       #   print mask.getValueUnsafe(x, y)
    #     i += 2

    # let
    #   sweepHeight = cutLines[currCutLine + 1] - cutLines[currCutLine]
    #   yFrac = (y.float32 - cutLines[currCutLine]) / sweepHeight
    # var i = 0
    # while i < sweep.len:
    #   let
    #     minXf1 = mix(sweep[i+0].atx, sweep[i+0].tox, yFrac)
    #     maxXf1 = mix(sweep[i+1].atx, sweep[i+1].tox, yFrac)
    #     minXi1 = minXf1.floor.int
    #     maxXi1 = maxXf1.floor.int
    #   for x in minXi1 .. maxXi1:
    #     mask.setValueUnsafe(x, y, 255)
    #   i += 2

  var
    currCutLine = 0
  for scanLine in cutLines[0].int ..< cutLines[^1].ceil.int:
    #print scanLine, "..<", scanLine + 1
    #print "  ", currCutLine, cutLines[currCutLine], "..<", cutLines[currCutLine + 1]
    fillCoverage(scanLine, currCutLine, sweeps[currCutLine])

    while cutLines[currCutLine + 1] < scanLine.float + 1.0:
      inc currCutLine
      if currCutLine == sweeps.len:
        break
      #print "  ", currCutLine, cutLines[currCutLine], "..<", cutLines[currCutLine + 1]
      fillCoverage(scanLine, currCutLine, sweeps[currCutLine])

  # print sweeps[^1]
  # print cutLines




  # var segments: seq[Segment]
  # while segments1.len > 0:
  #   #print segments1.len, segments.len
  #   var s = segments1.pop()
  #   var collision = false
  #   for y in cutLines:
  #     let scanLine = line(vec2(0, y), vec2(1, y))
  #     var at: Vec2
  #     if intersects(scanLine, s, at):
  #       at = at.roundBy(q)
  #       at.y = y
  #       if s.at.y != at.y and s.to.y != at.y:
  #         #print "seg2yline intersects!", a, y, at
  #         collision = true
  #         var s1 = segment(s.at, at)
  #         var s2 = segment(at, s.to)
  #         #print s.length, "->", s1.length, s2.length
  #         segments1.add(s1)
  #         segments1.add(s2)
  #         break

  #   if not collision:
  #     # means its touching, not intersecting
  #     segments.add(s)

  # # sort at/to in segments
  # # for s in segments.mitems:
  # #   if s.at.y > s.to.y:
  # #     swap(s.at, s.to)


  # #let blender = blendMode.blender()

  # for yScanLine in cutLines[0..^2]:

  #   var scanSegments: seq[Segment]
  #   for s in segments:
  #     if s.at.y == yScanLine:
  #       scanSegments.add(s)
  #   scanSegments.sort(proc(a, b: Segment): int =
  #     cmp(a.at.x, b.at.x))

  #   # if scanSegments.len mod 2 != 0:
  #   #   print "error???"
  #   #   print yScanLine
  #   #   print scanSegments
  #   #   quit()

  #   # TODO: winding rules will go here

  #   var trapezoids: seq[Trapezoid]
  #   for i in 0 ..< scanSegments.len div 2:
  #     let
  #       a = scanSegments[i*2+0]
  #       b = scanSegments[i*2+1]

  #     assert a.at.y == b.at.y
  #     assert a.to.y == b.to.y
  #     #assert a.at.x < b.at.x
  #     #assert a.to.x < b.to.x

  #     trapezoids.add(Trapezoid(
  #       nw: a.at,
  #       ne: b.at,
  #       se: b.to, # + vec2(0,0.7),
  #       sw: a.to # + vec2(0,0.7)
  #     ))

  #   var i = 0
  #   while i < trapezoids.len:

  #     let t = trapezoids[i]
  #     # print t
  #     let
  #       nw = t.nw
  #       ne = t.ne
  #       se = t.se
  #       sw = t.sw

  #     let
  #       height = sw.y - nw.y
  #       minYf = nw.y
  #       maxYf = sw.y
  #       minYi = minYf.floor.int
  #       maxYi = maxYf.floor.int

  #     # print t

  #     for y in minYi .. maxYi:
  #       let
  #         yFrac = (y.float - nw.y) / height
  #         minXf = mix(nw.x, sw.x, yFrac)
  #         maxXf = mix(ne.x, se.x, yFrac)
  #         minXi = minXf.floor.int
  #         maxXi = maxXf.floor.int
  #       #print yFrac
  #       # if not(minY.int == 58 or maxY.int == 58) or minX > 100:
  #       #   continue

  #       var ay: float32
  #       if y == minYi and y == maxYi:
  #         ay = maxYf - minYf
  #         # print "middle", maxYf, minYf, a
  #         #print "double", y, a, minY, maxY, round(a * 255)
  #       elif y == minYi:
  #         ay = (1 - (minYf - float32(minYi)))
  #         # print "min y", minYf, minYi, a
  #         #print "s", y, a, minY, round(a * 255)
  #       elif y == maxYi:
  #         ay = (maxYf - float32(maxYi))
  #         #print "max y", maxYf, maxYi, a
  #         # print "e", y, a, maxY, round(a * 255)
  #       else:
  #         ay = 1.0

  #       for x in minXi .. maxXi:
  #         var ax: float32
  #         # if x == minXi:
  #         #   a2 = (1 - (minXf - float32(minXi)))
  #         #   #a2 = 1.0
  #         # elif x == maxXi:
  #         #   a2 = (maxXf - float32(maxXi))
  #         #   #a2 = 1.0
  #         # else:
  #         #   a2 = 1.0

  #         if x.float32 < max(nw.x, sw.x):
  #           ax = 0.5
  #         elif x.float32 > min(ne.x, se.x):
  #           ax = 0.25
  #         else:
  #           ax = 1.0

  #         let backdrop = mask.getValueUnsafe(x, y)
  #         mask.setValueUnsafe(x, y, backdrop + floor(255 * ay * ax).uint8)
  #         # if x == 100 and y == 172:
  #         #   print backdrop, round(255 * a * a2).uint8
  #         #   print mask.getValueUnsafe(x, y)

  #     inc i

block:
  # Rect
  print "rect"
  #var image = newImage(200, 200)

  # rect
  # var p = Path()
  # p.moveTo(50.5, 50.5)
  # p.lineTo(50.5, 150.5)
  # p.lineTo(150.5, 150.5)
  # p.lineTo(150.5, 50.5)
  # p.closePath()

  ## rhobus
  var p = Path()
  p.moveTo(100, 50)
  p.lineTo(150, 100)
  p.lineTo(100, 150)
  p.lineTo(50, 100)
  p.closePath()

  # ## heart
  # var p = parsePath("""
  #   M 20 60
  #   A 40 40 90 0 1 100 60
  #   A 40 40 90 0 1 180 60
  #   Q 180 120 100 180
  #   Q 20 120 20 60
  #   z
  # """)

  ## cricle
  # var p = Path()
  # p.arc(100, 100, 50, 0, PI * 2, true)
  # p.closePath()

  # image.fill(rgba(255, 255, 255, 255))
  #image.fillPath2(p, color(0, 0, 0, 1))

  var mask = newMask(200, 200)
  timeIt "rect sweeps", 100:
    for i in 0 ..< 100:
      mask.fill(0)
      mask.fillPath2(p)
      #image.fillPath2(p, color(0, 0, 0, 1))
  mask.writeFile("experiments/trapezoids/output_sweep.png")

  var mask2 = newMask(200, 200)
  timeIt "rect scanline", 10:
    for i in 0 ..< 100:
      mask2.fill(0)
      mask2.fillPath(p)
  mask2.writeFile("experiments/trapezoids/output_scanline.png")

  let (score, image) = diff(mask.newImage, mask2.newImage)
  print score
  image.writeFile("experiments/trapezoids/output_diff.png")



# block:
#   # Rhombus
#   print "rhombus"
#   var image = newImage(200, 200)
#   image.fill(rgba(255, 255, 255, 255))

#   var p = Path()
#   p.moveTo(100, 50)
#   p.lineTo(150, 100)
#   p.lineTo(100, 150)
#   p.lineTo(50, 100)
#   p.closePath()

#   image.fillPath2(p, color(0, 0, 0, 1))

#   image.writeFile("experiments/trapezoids/rhombus.png")

# block:
#   # heart
#   print "heart"
#   var image = newImage(400, 400)
#   image.fill(rgba(0, 0, 0, 0))

#   var p = parsePath("""
#     M 40 120 A 80 80 90 0 1 200 120 A 80 80 90 0 1 360 120
#     Q 360 240 200 360 Q 40 240 40 120 z
#   """)

#   var mask = newMask(image)
#   mask.fillPath2(p)

#   image.draw(mask, blendMode = bmOverwrite)

#   image.writeFile("experiments/trapezoids/heart.png")

# block:
#   # l
#   print "l"
#   var image = newImage(500, 800)
#   image.fill(rgba(255, 255, 255, 255))

#   var p = parsePath("""
#     M 236 20 Q 150 22 114 57 T 78 166 V 790 L 171 806 V 181 Q 171 158 175 143 T 188 119 T 212 105.5 T 249 98 Z
#   """)

#   image.fillPath2(p, color(0, 0, 0, 1))

#   image.writeFile("experiments/trapezoids/l.png")

# block:
#   # g
#   print "g"
#   var image = newImage(500, 800)
#   image.fill(rgba(255, 255, 255, 255))

#   var p = parsePath("""
#     M 406 538 Q 394 546 359.5 558.5 T 279 571 Q 232 571 190.5 556 T 118 509.5 T 69 431 T 51 319 Q 51 262 68 214.5 T 117.5 132.5 T 197 78.5 T 303 59 Q 368 59 416.5 68.5 T 498 86 V 550 Q 498 670 436 724 T 248 778 Q 199 778 155.5 770 T 80 751 L 97 670 Q 125 681 165.5 689.5 T 250 698 Q 333 698 369.5 665 T 406 560 V 538 Z M 405 152 Q 391 148 367.5 144.5 T 304 141 Q 229 141 188.5 190 T 148 320 Q 148 365 159.5 397 T 190.5 450 T 235.5 481 T 288 491 Q 325 491 356 480.5 T 405 456 V 152 Z
#   """)

#   image.fillPath2(p, color(0, 0, 0, 1))

#   image.writeFile("experiments/trapezoids/g.png")
