potato.lua

--[[
[Description]
Draws a vector potato, based on a circle approximation with bezier curves,
with variations to the key and control points to make bumps.

[Usage]
potato(radius)
potato(radius, rvar)
potato(radius, rvar, avar)
potato(radius, rvar, avar, hlvar)
potato(radius, rvar, avar, hlvar, havar)
potato(radius, rvar, avar, hlvar, havar, keypoints)
potato(radius, rvar, avar, hlvar, havar, keypoints, clockwise)

[Arguments]
radius: base radius of the potato, in pixels
rvar: radius variation, between 0 and 1 (default 0)
avar: keypoint angle variation, in radians (default 0)
hlvar: control point distance variation, between 0 and 1 (default 0)
havar: control point angle variation, in radians (default 0)
keypoints: number of keypoints used (default 8)
clockwise: drawing direction, boolean (default false)

[Notes]
(rvar, avar, hlvar, havar, keypoints)
= (0.2, math.pi/18, 0.2, math.pi/12, 8)
Makes a pretty good potato.
This function does not include drawing tags, only vector commands.
--]]
function potato(radius, rvar, avar, hlvar, havar, keypoints, clockwise)
    keypoints = keypoints or 8
    havar = havar or 0
    hlvar = hlvar or 0
    avar = avar or 0
    rvar = rvar or 0
  
    local halfpi = math.pi / 2
    local hbase = 4/3 * math.tan(math.pi / (2 * keypoints))
    local points = {}
    local mult = clockwise and -1 or 1
  
    for i = 1, keypoints do
        r = radius + (2 * math.random() - 1) * rvar * radius
        a = i / keypoints * 2 * math.pi + (2 * math.random() - 1) * avar
        local x = r * math.cos(a)
        local y = r * math.sin(a)
        points[i] = {r = r, a = a, x = x, y = y}
    end
  
    points[keypoints+1] = points[1]
  
    for i = 1, keypoints do
        local p = points[i]
    
        local hangle = (2 * math.random() - 1) * havar
        local l = hbase * r + (2 * math.random() - 1) * hlvar * hbase * r
        points[i+1].h1 = {l = l, a = hangle,
            x = p.x + mult * l * math.cos(p.a + halfpi + hangle),
            y = p.y + mult * l * math.sin(p.a + halfpi + hangle)}
    
        l = hbase * r + (2 * math.random() - 1) * hlvar * hbase * r
        points[i].h2 = {l = l, a = hangle,
            x = p.x - mult * l * math.cos(p.a + halfpi + hangle),
            y = p.y - mult * l * math.sin(p.a + halfpi + hangle)}
    end
  
    points[1].h1 = points[keypoints+1].h1
  
    local str = "m " .. points[keypoints].x .. " " .. points[keypoints].y .. " "
  
    for i = 1, keypoints do
        local p = points[i]
        str = str .. "b " .. p.h1.x .. " " .. p.h1.y .. " "
            .. p.h2.x .. " " .. p.h2.y .. " "
            .. p.x .. " " .. p.y .. " "
    end
  
    return str
  end