Subversion Repositories Kolibri OS

--DawnBringer function library v1.14 (some drawing replaced)

--** THIS IS NOT A RUNNABLE SCRIPT! **

--by Richard Fhager

-- http://hem.fyristorg.com/dawnbringer/

-- Email: dawnbringer@hem.utfors.se

-- MSN:   annassar@hotmail.com

--

-- Many functions in here was adopted from Evalion, a Javascript codecrafting/imageprocessing project

-- http://goto.glocalnet.net/richard_fhager/evalion/evalion.html

--

--

-- You may access these functions in your own scripts by loading this library,

-- just add the follwing line as one of the first instructions:

--

-- run("dawnbringer_lib")

--

-- or

--

-- run("../libs/dawnbringer_lib.lua")

--

--

-- Note that the functions must be called with the full library object-name, "db.function_name..."

--

-- Global library object

db = {}

-- *************************************

-- ***      Text & Conversions       ***

-- *************************************

--

--

function db.rgb2HEX(r,g,b,prefix)

  local c,n,s,t,z

  c = {r,g,b}

  z = {"0",""}

  t = ""

  for n = 1, 3, 1 do

  s = string.upper(string.format("%x",c[n]))

  t = t..z[#s]..s

     --s = tonumber(c[n],16)

     --t = t..s

  end

  return prefix..t

end

--

-- ... eof Text & Conversions ...

--

-- *************************************

-- ***    Custom Math Functions     ***

-- *************************************

--

--

function db.sign(v)

    local s

    s = 0

    if v > 0 then s = 1; end

    if v < 0 then s = -1; end

    return s

end

--

function db.distance(ax,ay,bx,by) return math.sqrt((ax-bx)^2 + (ay-by)^2); end

--

function db.rotation (rot_ang,hub_x,hub_y,x,y) -- Rotate coordinates x & y relative hub

  local new_ang,dist,m,xd,yd,v; m = math

  xd=hub_x-x;

  yd=hub_y-y;

  if (not(xd==0 and yd==0)) then

   v = -90; if xd < 0 then v = 90; end

   new_ang = m.atan(yd/xd) - (v+rot_ang) * m.pi/180;

   dist = m.sqrt(xd*xd+yd*yd);

   x = hub_x - m.sin(new_ang)*dist;

   y = hub_y + m.cos(new_ang)*dist;

  end

  return math.floor(x),math.floor(y) -- For drawing purposes

end

--

--

function db.recursiveSum(div,rlev) -- divisons per recursion,recursion levels

 local s,i,m

 s,m = 1,1

 for i = 1, rlev, 1 do

  m = m*div

  s = s + m

 end

 return s

end

--

--

-- ... eof Custom Math Functions ...

--

-- *************************************

-- ***     Fractional Scenery        ***

-- *************************************

--

function db.setSceneryPalette()

 db.colorCigarr(10,28,true) -- 250 colors

 setcolor(250, 208,48,48)

 setcolor(251, 48,208,48)

 setcolor(252, 48,48,208)

 setcolor(253, 224,224,64)

 setcolor(254, 224,64,224)

 setcolor(255, 64,224,224)

end

--

--

function db.star(xf,yf,sx,sy,rgb,haz,out,lum)

 local n,c,dist; c={}

 dist = haz + out * math.sqrt((xf-sx)^2+(yf-sy)^2);

 for n = 1, 3, 1 do c[n] = (rgb[n] * lum) / dist; end

 return c;

end

--

--

function db.zoom(xf,yf,zoom,panx,pany) -- Zoom and Pan in a fractional coord-system

  xf = (xf-0.5)/zoom + 0.5 + panx;

  yf = (yf-0.5)/zoom + 0.5 + pany;

  return xf,yf

end

--

--

function db.rotationFrac(rot_ang,hub_x,hub_y,x,y) -- Rotate coordinates x & y relative hub

  local new_ang,dist,m,xd,yd,v; m = math

  xd=hub_x-x;

  yd=hub_y-y;

  if (not(xd==0 and yd==0)) then

   v = -90; if xd < 0 then v = 90; end

   new_ang = m.atan(yd/xd) - (v+rot_ang) * m.pi/180;

   dist = m.sqrt(xd*xd+yd*yd);

   x = hub_x - m.sin(new_ang)*dist;

   y = hub_y + m.cos(new_ang)*dist;

  end

  return x,y

end

--

--

function db.twirl(x,y,arms,trot,tpow,tang)

 local b,ang,vx,vy,vr,m,deg,tw

 m=math; deg=math.pi/180; tw=.5;

 if (not(x==.5 and y==.5)) then

  ang = m.atan((.5-y)/(.5-x));

  b = 0; if (x>.5) then b = m.pi; end

  vx = .5-x; vy = .5-y; vr = m.pow(m.sqrt(vx*vx+vy*vy),tpow);

  tw = .5+m.sin(-tang*deg+vr*trot+(ang + b)*arms)*.5;

 end

 return tw;

end

--

--- Alpha filters

--

function db.alpha1(x,y,amp) -- Coord, Amplify: 0..n

 local p,a,xh,yh,m

 xh=0.5-x; yh=0.5-y; m = math

 p = m.pow(xh*xh+yh*yh,0.7);

 a = m.cos(32*m.pi*p)*m.sin(8*m.pi*(xh+yh));

 return 1 + (a * amp)

end

--

--

-- ... eof Fractional Scenery ...

--

-- *************************************

-- ***    Custom Array Functions     ***

-- *************************************

--

-- Ok, I don't know Lua that well (still unsure about some scopes & refs etc.)

-- And some features may not be active in Grafx2. So, some of the follwing functions

-- may exist in Lua/Grafx2...but since I'm not sure if and how they work - I'll prefer

-- to add a set of my own of known performance.

--

function db.newArrayInit(xs,val)

  local x,ary; ary = {}

   for x = 1, xs, 1 do

     ary[x] = val

   end

  return ary

end

--

--

function db.newArrayInit2Dim(xs,ys,val)

  local x,y,ary; ary = {}

  for y = 1, ys, 1 do

   ary[y] = {}

   for x = 1, xs, 1 do

     ary[y][x] = val

   end

  end

  return ary

end

--

--

-- Merge two arrays into a NEW one: array_c = db.newArrayMerge(array_b,array_b)

--

function db.newArrayMerge(a,b)

  local n,ary; ary = {}

  for n = 1, #a, 1 do

   ary[n] = a[n]

  end

  for n = 1, #b, 1 do

   ary[n+#a] = b[n]

  end

  return ary

end

--

--

-- Generate a copy of an array with a new value added Last

--

function db.newArrayInsertLast(a,val)

  local n,ary; ary = {}

  for n = 1, #a, 1 do

   ary[n] = a[n]

  end

  ary[#a+1] = val

  return ary

end

--

--

-- Generate a copy of an array with a new value added First

--

function db.newArrayInsertFirst(a,val)

  local n,ary; ary = {}

  ary[1] = val

  for n = 2, #a+1, 1 do

   ary[n] = a[n-1]

  end

  return ary

end

--

--

function db.ary2txt(ary) -- One & two dimensions supported [a,b] -> "a,b". [[a,b],[c,d]] -> "a-b, c-d"

 local t,n,m,v

 t = ""

 for n = 1, #ary, 1 do

   if type(ary[n]) == "table" then

     t = t..ary[n][1]

     for m = 2, #ary[n], 1 do

       t = t.."-"..ary[n][m]

     end

   else t = t..ary[n];

   end

   t = t..", "

 end

 return t

end

--

--

-- *** Array data manipulation ***

--

--

-- InsertionSort Array, this is chaos...I'm confused and stomped...don't understand how Lua works...

-- ...sorting seem be to ok but this code is ugly...

-- Sort LO-HI

--

-- Screwed up or confused thing here I think, perhaps lo-hi/hi-lo. This is working lo-hi but the code

-- looks like hi-lo...edit this some day

--

function db.sorti(d,idx)

   local a,j,tmp,l,e

   l = #d

   for a=2, l, 1 do

    tmp = d[a];

    e = a

    for j=a, 2, -1 do

      e = j

      if d[j-1][idx] > tmp[idx] then d[j] = d[j-1]; e = j-1; else break; end;

    end;

    d[e] = tmp; -- WHY THE F**K CAN'T YOU READ j HERE!?! STUPID ASSUCKING LANGUAGE

   end;

   --return d

end

--

--

function db.shuffle(list)

 local i,n,t

 for n = #list, 2, -1 do

  i = 1+math.floor(math.random() * n)

  t = list[n]; list[n] = list[i]; list[i] = t

 end

end

--

--

-- ... eof Custom Array Functions ...

--

-- *************************************

-- ***   Misc. Logical Operations    ***

-- *************************************

--

-- palList [r,g,b,palindex] is expected only to contain unique colors

-- index = -1 --> index of list

--

function db.makeIndexList(list,index)

  local n,ilist

  ilist = {}

  for n = 1, #list, 1 do

   if (index > 0) then ilist[n] = list[n][index]; end

   if (index == -1) then ilist[n] = n; end

  end

  return ilist

end

--

--

-- Return a list of all possible (non-same) pairs from the entries in a list

-- [a,b,c] --> [[a,b],[a,c],[b,c]]

-- (All entries are treated as unique. i.e it's only the INDEX that counts)

-- mode = 0: Only unique pairs (m = (n^2 - n)/2), [a,b] --> [[a,b]]

-- mode = 1: All pairs, i.e mirror versions as well. (m = n^2 - n), [a,b] --> [[a,b], [b,a]]

--

function db.pairsFromList(list,mode)

 local a,b,l,n,pairs

 pairs = {}

 l = #list

 n = 1

 for a = 1, l, 1 do

   for b = a+1, l, 1 do

     pairs[n] = {list[a],list[b]}; n = n + 1

     if mode == 1 then pairs[n] = {list[b],list[a]}; n = n + 1; end

   end

 end

 return pairs

end

--

function db.valueInArray(ary,val)

 local n,res

 res = false

 for n = 1, #ary, 1 do

   if ary[n] == val then res = true; break; end

 end

 return res

end

-- RAMP specific

-- Remove initial pair (palList) colors from pallist

function db.initiateRamp(pair,pallist,pal_index)

  local n,found,plist

  plist = {}

  found = 1

  for n = 1, #pallist, 1 do

   if db.valueInArray(pair,pallist[n]) == false then

    plist[found] = pallist[n]; found = found + 1;

   end

  end

  pair[pal_index] = plist -- ex: ["pal"]

  return pair -- Is now a 2 color RAMP

end

--

-- Remove new col entry from ramp's pallist and add it to the ramp, returns an updated ramp

-- RampList = [1,2] ["pal"] = palList = [3,4,5], addindex = 3

-- --> [1,2,3] palList = [4,5]

function db.updateRamp(ramp,addindex,pal_index)

  local n,found,pallist,plist,newramp

  plist = {}

  pallist = ramp[pal_index]

  -- New palList without added color to IndexList

  found = 1

  for n = 1, #pallist, 1 do

   if pallist[n] ~= addindex then

    plist[found] = pallist[n]; found = found + 1;

   end

  end

  newramp = db.newArrayInsertLast(ramplist,addindex)

  newramp[pal_index] = plist

  return rlist

end

--

-- Returns a list of all inital ramps from color pairs

--

-- Weeds out bad pairs, attaches remaining palette colors and the first rgb-vector

--

--

function db.initiateRampList(pairs,pallist,pal_index,vec_index,min,maxmult,rw,gw,bw)

 local n,ramplist,newpairs,accept,dist,c1,c2,max,rD,gD,bD

 ramplist = {}

 max = min + (142 / math.sqrt(#pallist)) * maxmult -- min ex: 8-12

 accept = 0

 for n = 1, #pairs, 1 do

  c1 = pallist[pairs[n][1]]

  c2 = pallist[pairs[n][2]]

  rD = c2[1] - c1[1]

  gD = c2[2] - c1[2]

  bD = c2[3] - c1[3]

  dist = math.sqrt( (rw*rD)^2 + (gw*gD)^2 + (bw*bD)^2 )

  if dist >= min and dist <= max then

    accept = accept + 1; ramplist[accept] = db.initiateRamp(pairs[n],pallist,pal_index);

    ramplist[accept][vec_index] = {rD, gD, bD, dist}; -- Add first color vector, ONLY KEEP DISTANCE?

  end

 end

 return ramplist

end

function db.findRampExpansionColors(ramp)

 local clist

 clist = {}

 -- Calculate vectors here?

 return clist

end

function db.findRAMPS(min_len, max_len)

 local i,n,c,pallist,ramp,ramplist,pairs,spairs,palindex,vecindex,found,donelist,newlist,dones

 local colorlist

 palindex = "pal"

 vecindex = "vector"

 pallist =  db.fixPalette(db.makePalList(256), 0)

 pairs =    db.pairsFromList(db.makeIndexList(pallist,-1), 0)

 ramplist = db.initiateRampList(pairs,pallist,palindex,vecindex, 8,0.75, 0.26,0.55,0.19)

 -- MIN_LEN = 5

 -- MAX_LEN = 10

 -- Split Ramp-build into two parts:

 -- 1. Build ramps >= MIN_LEN, NONE added to 'Done'

 -- 2. Run til no more ramps can be expanded or reaches MAX_LEN, ALL ramps added to 'Done'

 for i = 1, (min_len - 2), 1 do -- Assuming 2 for inital pairs (2 color ramps)

  newlist = {}

  found = 0

  for n = 1, #ramplist, 1 do

    ramp = ramplist[n]

    colorlist = db.findRampExpansionColors(ramp) -- Colors that can split the current ramp into new expanded ramps

    for c = 1, #colorlist, 1 do

     found = found + 1; newlist[found] = db.updateRamp(ramp,colorlist[c],palindex); -- Ramp is expanded by 1 color

    end

  end

  ramplist = newlist

 end

 donelist = {}; dones = 0

 repeat

  newlist = {}

  found = 0

  for n = 1, #ramplist, 1 do

    ramp = ramplist[n]

    if true == false then

     found = found + 1; newlist[found] = db.updateRamp(ramp,color,palindex);

      else

      dones = dones + 1; donelist[dones] = ramp;

    end

  end

  --ramplist = newlist

 until found == 0

 return #pairs.." - "..#ramplist

end

--

-- ... eof Misc. Logical Operations ...

--

-- ***************************************

-- *** General RGB-Color Modifications ***

-- ***************************************

--

function db.makeComplementaryColor(r,g,b,brikeeplev) -- Lev: 0 = Normal, 1 = Loose, 2 = Strict

 local bri_o,bri_n,bdiff

 function cap(v) return math.max(0,math.min(v,255)); end

 bri_o = db.getBrightness(r,g,b)

 r,g,b = db.shiftHUE(r,g,b,180)

 if brikeeplev > 0 then

  for n = 0, brikeeplev*3-1, 1 do -- Must iterate to reduce brightness error

    bri_n = db.getBrightness(r,g,b)

    bdiff = (bri_o - bri_n) / 2 * brikeeplev

    r = cap(r + bdiff)

    g = cap(g + bdiff)

    b = cap(b + bdiff)

  end

 end

 return r,g,b

end

--

-- *** Color balance ***

--

-- bri_flag:   Preserve brightness

-- loose_flag: Loose preservation restrictions for brightness and balance

--

-- Jeez, was this a tricky sucker; color-balance is just adding and capping...

-- but trying color-balance with preserved perceptual brightness is a different monster...

-- ...so bad I could only solve it by iterative error correction.

--

function db.ColorBalance(r,g,b,rd,gd,bd,bri_flag,loose_flag) -- preserve brightness

 local rw,gw,bw,ri,gi,bi,itot,rni,gni,bni,ro,go,bo,ovscale,lev,count,rt,gt,bt,rf,gf,bf,bri

 -- Dawn 3.0, [0.26,0.55,0.19], 0-255 bri-colorscale adjust = 1.56905

 rw,gw,bw = 0.26, 0.55, 0.19

 function cap(v) return math.min(255,math.max(v,0)); end

  bri = db.getBrightness(r,g,b)

 -- Loose brightness & balance preservation, a good compromise.

 if bri_flag == true and loose_flag == true then

   lev = (rd + gd + bd) / 3

   rd = rd - lev

   gd = gd - lev

   bd = bd - lev

   brin = db.getBrightness(cap(r+rd),cap(g+gd),cap(b+bd))

   itot = brin - bri

   rd = rd - itot

   gd = gd - itot

   bd = bd - itot

 end

 if bri_flag == true and loose_flag == false then

  itot = 255

  count = 0

   -- Normalize (Yup, it's right only to normalize once first..cont.norm. will have some counter-effect)

  lev = (rd + gd + bd) / 3

  rd = rd - lev

  gd = gd - lev

  bd = bd - lev

 repeat

  --messagebox("Norm:"..rd..", "..gd..", "..bd)

  -- Calculate total brightness change

  -- Note: Perceptual Brightness is exponential, and can't be delta-adjusted for anything other than greyscales.

  -- Although the formula for the new brightness corrected normalization level can can be derived...

  -- ...it doesn't do much good since the bigger problem is overflow outside the 0-255 boundary.

  -- As for now, I see no other means to solve this issue than with iterative error-correction.

  rt = r+rd

  gt = g+gd

  bt = b+bd

  itot = 9e99

  rni = rd

  gni = gd

  bni = bd

  -- We can get brightness of negative values etc. So bri-correction is put on hold until values are scaled down

  if (rt>=0 and gt>=0 and bt>=0) and (rt<256 and gt<256 and bt<256) then

    brin = db.getBrightness(rt,gt,bt)

    itot = brin - bri

    --messagebox("Bri Diff: "..itot)

    -- Brightness adjusted balance

     rni = rd - itot

     gni = gd - itot

     bni = bd - itot

  end

  --messagebox("Bri Adj Bal:"..rni..", "..gni..", "..bni)

   -- Apply balance to find overflow (as fraction of the channel change)

   ro = math.max( math.max((r + rni)-255,0), math.abs(math.min((r + rni),0)) ) / math.max(math.abs(rni),1)

   go = math.max( math.max((g + gni)-255,0), math.abs(math.min((g + gni),0)) ) / math.max(math.abs(gni),1)

   bo = math.max( math.max((b + bni)-255,0), math.abs(math.min((b + bni),0)) ) / math.max(math.abs(bni),1)

  ovscale = 1 - math.max(ro,go,bo)

  -- Scaling balances might be logically incorrect (as they can be seen as constant differences)

  -- But scaling DOWN is quite harmless and I don't see how it could be done otherwise...

  -- ex: +10 red, +5 blue: Scale x2   = +20 red, +10 blue -> More red over blue than ordered, a contrast behaviour.

  --     +10 red, +5 blue: Scale x0.5 = +5 red, +2.5 blue -> Less of everything, but a part of the order. Harmless?

  --

  rd = rni * ovscale

  gd = gni * ovscale

  bd = bni * ovscale

  count = count + 1

  --messagebox("Final bal:"..rd..", "..gd..", "..bd)

 until math.abs(itot) < 1 or count > 5

 end

 rf = r + rd

 gf = g + gd

 bf = b + bd

 --messagebox("Result color:"..rf..", "..gf..", "..bf)

 return rf,gf,bf

end

--

--

-- bri_flag: Preserve brightness

-- cap_flag: Cap new color at 0-255, has a desaturating effect for large values.

--

function db.ColorBalanceXXX(r,g,b,rd,gd,bd,bri_flag,cap_flag) -- preserve brightness

 local rf,gf,bf

 if cap_flag == true then

  rd = math.min(255,math.max(0, r+rd)) - r

  gd = math.min(255,math.max(0, g+gd)) - g

  bd = math.min(255,math.max(0, b+bd)) - b

 end

 local rw,gw,bw,ri,gi,bi,itot,rni,gni,bni,ro,go,bo,ovscale

 -- Dawn 3.0, [0.26,0.55,0.19], 0-255 bri-colorscale adjust = 1.56905

 rw,gw,bw = 0.26, 0.55, 0.19

 if bri_flag == true then

  -- Calculate total brightness change

  --ri = rd * rw

  --gi = gd * gw

  --bi = bd * bw

  --itot = math.sqrt(ri^2 + gi^2 + bi^2)

  bri  = db.getBrightness(r,g,b)

  brin = db.getBrightness(r+rd,g+gd,b+bd)

  itot = brin - bri

  -- Normalized and Brightness adjusted balance

  rni = rd - itot

  gni = gd - itot

  bni = bd - itot

  -- Apply balance to find overflow (as fraction of the channel change)

  ro = math.max( math.max((r + rni)-255,0), math.abs(math.min((r + rni),0)) ) / math.max(math.abs(rni),1)

  go = math.max( math.max((g + gni)-255,0), math.abs(math.min((g + gni),0)) ) / math.max(math.abs(gni),1)

  bo = math.max( math.max((b + bni)-255,0), math.abs(math.min((b + bni),0)) ) / math.max(math.abs(bni),1)

  ovscale = 1 - math.max(ro,go,bo)

  rd = rni * ovscale

  gd = gni * ovscale

  bd = bni * ovscale

 end

 rf = r + rd

 gf = g + gd

 bf = b + bd

 return rf,gf,bf

end

--

--

function db.getContrast(ch) -- Channel, returns fraction -1..0..1, negative for ch < 127.5

 --return math.abs((ch / 127.5) - 1)

 return (ch / 127.5) - 1

end

--

--

function db.getAvgContrast(r,g,b)

 return (math.abs(db.getContrast(r)) + math.abs(db.getContrast(g)) + math.abs(db.getContrast(b))) / 3

end

--

--

-- Mode = 0: Proportional - all colors reach max contrast at 100%

--

-- Mode = 1: Linear - percentage simply added

--

function db.changeContrastOLD(r,g,b,prc,mode)

 local m,rd,gd,bd,rv,gv,bv,rc,gc,bc,base,sign

 base = 1; sign = 1

 if prc < 0 then base = 0; sign = -1; end -- decontrast

 m = prc / 100 * sign

 -- mode 0

 rc = db.getContrast(r)

 rd = (base - math.abs(rc)) * m  * db.sign(rc)

 rv = (rc+rd+1) * 127.5

 gc = db.getContrast(g)

 gd = (base - math.abs(gc)) * m  * db.sign(gc)

 gv = (gc+gd+1) * 127.5

 bc = db.getContrast(b)

 bd = (base - math.abs(bc)) * m  * db.sign(bc)

 bv = (bc+bd+1) * 127.5

 return rv,gv,bv

end

--

function db.changeContrast(r,g,b,prc) -- Photoshop style

 local m,rd,gd,bd,rv,gv,bv,rc,gc,bc

 m = 1 + math.pow((255 / 100 * prc),3) / (255*255)

 -- decontrast

 if prc < 0 then

  m = 1 - math.abs(prc)/100

 end

 rc = db.getContrast(r)

 rd = rc * m

 rv = (rd+1) * 127.5

 gc = db.getContrast(g)

 gd = gc * m

 gv = (gd+1) * 127.5

 bc = db.getContrast(b)

 bd = bc * m

 bv = (bd+1) * 127.5

 return rv,gv,bv

end

--

function db.getBrightness(r,g,b) -- 0-255

 local bri

 --bri = (r+g+b)/3

 --bri = r*0.3 + g*0.59 + b*0.11 -- Luma Y'601

 --bri = math.sqrt((r*0.3)^2 + (g*0.59)^2 + (b*0.11)^2) -- Luma Y'601

 --bri = r*0.245 + g*0.575 + b*0.18 -- Dawn 2.0

 bri = math.sqrt((r*0.26)^2 + (g*0.55)^2 + (b*0.19)^2) * 1.56905 -- Dawn 3.0

 return bri

end

--

--

-- Note on desaturation: These functions are all junk, the only way to desaturate

--                       is to fade a color into it's corresponding greyscale.

--

--

function db.desaturate(percent,r,g,b) -- V1.0 by Richard Fhager

 local a,p

 p = percent / 100

 a = (math.min(math.max(r,g,b),255) + math.max(math.min(r,g,b),0)) * 0.5 * p

 r = r + (a-r*p) -- a+r*(1-p)

 g = g + (a-g*p)

 b = b + (a-b*p)

 return r,g,b

end

--

--

function db.desaturateA(percent,c) -- array version

 local r,g,b,a

 r = c[1]

 g = c[2]

 b = c[3]

 p = percent / 100

 a = (math.min(math.max(r,g,b),255) + math.max(math.min(r,g,b),0)) * 0.5 * p

 r = r + (a-r*p)

 g = g + (a-g*p)

 b = b + (a-b*p)

 return {r,g,b}

end

--

--

function db.desatAVG(desat,c) -- Desaturation, simpe average

 r = c[1]

 g = c[2]

 b = c[3]

 p = desat / 100

 a = (r+g+b)/3

 r = r + p*(a-r)

 g = g + p*(a-g)

 b = b + p*(a-b)

 return {r,g,b}

end

--

--

function db.getSaturation(r,g,b) -- HSL

  local M,m,c,s,l

  M = math.max(r,g,b)

  m = math.min(r,g,b)

  c = (M - m)/255

  s = 0

  if c ~= 0 then

    --l = (0.3*r + 0.59*g + 0.11*b)/255 -- HSLuma: Y'601

    l = (M+m)/510 -- This produces a quite "correct looking" divison of saturation

    if l <= 0.5 then s = c / (2*l); end

    if l  > 0.5 then s = c / (2-2*l); end

  end

  return math.min(255,s * 255)

end

--

--

function db.getTrueSaturationX(r,g,b) -- Distance from grayscale axis. Not HSV/HSL

 local sat,bri

 bri = (r+g+b) / 3

 sat = math.min(255, math.sqrt((r-bri)^2 + (g-bri)^2 + (b-bri)^2) * 1.224744875)

 return sat

end

--

-- WIP. Trying to find a more natural model for estimating Saturation

-- Current: (HSL + True) / 2

function db.getAppSaturation(r,g,b)

  return  math.min(255, (db.getSaturation(r,g,b) + db.getTrueSaturationX(r,g,b)) / 2)

end

--

--

function db.saturate(percent,r,g,b)

  local a,m,p,mc

  a = (math.min(math.max(r,g,b),255) + math.max(math.min(r,g,b),0)) * 0.5

  m = math.min(255-math.max(r,g,b), math.min(r,g,b))

  p = percent * (m / 100)

  mc = math.max((r-a),(g-a),(b-a)) -- Can this be derived elsewhere?

  if mc ~= 0 then

   r = r + (r-a) * p / mc

   g = g + (g-a) * p / mc

   b = b + (b-a) * p / mc

  end

  return r,g,b

end

--

--

-- Super Saturate: Better than Photoshop etc.

--

-- Higher than 100% power is ok

--

function db.saturateAdv(percent,r,g,b,brikeeplev,greydamp) -- brikeep = 0 - 2

  local a,m,p,mc,bri_o,bri_n,bdiff,mx,mi,adj,q,n

   function cap(v) return math.max(0,math.min(v,255)); end

  mx = math.max(r,g,b)

  mi = math.min(r,g,b)

  bri_o = db.getBrightness(r,g,b)

  a = (math.min(mx,255) + math.max(mi,0)) * 0.5

  m = math.min(255-mx, mi)

  p = percent * (m / 100)

  mc = math.max((r-a),(g-a),(b-a)) -- Can this be derived elsewhere?

  if mc ~= 0 and m ~= 0 then

   adj = math.min(1,(mx - mi) / m) -- Reduce effect on low saturation

   if greydamp == false then adj = 1; end

   q = p / mc * adj

   r = cap( r + (r-a) * q )

   g = cap( g + (g-a) * q )

   b = cap( b + (b-a) * q )

  end

  for n = 0, brikeeplev*2, 1 do -- Must iterate to reduce brightness error

    bri_n = db.getBrightness(r,g,b)

    bdiff = (bri_o - bri_n) / 2 * brikeeplev

    r = cap(r + bdiff)

    g = cap(g + bdiff)

    b = cap(b + bdiff)

  end

  return r,g,b

end

--

--

-- Lightness: Darken / Brighten color (Argument and returnvalue is a rgb-list)

--            Rate of change is inversely proportional to the distance of the max/min.

--            i.e. all colors/channels will reach max/min at the same time (at 0 or 100 %)

--            (As opposed to 'Brightness' where all channels are changed by a constant value)

--

function db.lightness(percent,c)

 local v,r,g,b,p

 r = c[1]

 g = c[2]

 b = c[3]

 p = math.abs(percent/100)

 v = 255

 if percent < 0 then v = 0; end

 r = r + (v - r)*p

 g = g + (v - g)*p

 b = b + (v - b)*p

 return {r,g,b}

end

--

--

function db.changeLightness(r,g,b,percent)

 local v

 v = db.lightness(percent,{r,g,b})

 return v[1],v[2],v[3]

end

--

--

function db.getLightness(r,g,b) -- HSL bi-hexcone

  return (math.max(r,g,b) + math.min(r,g,b)) / 2

end

--

--

function db.shiftHUE(r,g,b,deg) -- V1.3 R.Fhager 2007, (Heavily derived code, hehe...)

 local c,h,mi,mx,d,s,p,i,f,q,t

 c = {g,b,r}

 mi = math.min(r,g,b)

 mx = math.max(r,g,b); v = mx;

 d = mx - mi;

 s = 0; if mx ~= 0 then s = d/mx; end

 p = 1; if g ~= mx then p = 2; if b ~= mx then p = 0; end; end

 if s~=0 then

  h=(deg/60+(6+p*2+(c[1+p]-c[1+(p+1)%3])/d))%6;

  i=math.floor(h);

  f=h-i;

  p=v*(1-s);

  q=v*(1-s*f);

  t=v*(1-s*(1-f));

  c={v,q,p,p,t,v}

  r = c[1+i]

  g = c[1+(i+4)%6]

  b = c[1+(i+2)%6]

 end

 return r,g,b

end

--

--

function db.getHUE(r,g,b,greytol) -- 0-6 (6.5 = Greyscale), mult. with 60 for degrees

 -- 1 Color diff is roughly detected by Tolerance = 0.0078125 (Tol. incr. with lightness etc.)

 local c,h,mi,mx,d,s,p,i,f,q,t

 c = {g,b,r}

 mi = math.min(r,g,b)

 mx = math.max(r,g,b); v = mx;

 d = mx - mi;

 s = 0; if mx ~= 0 then s = d/mx; end

 p = 1; if g ~= mx then p = 2; if b ~= mx then p = 0; end; end

 h = 6.5 -- for custom graphical purposes

 if s>greytol then -- can't use >=

  h=(6+p*2+(c[1+p]-c[1+(p+1)%3])/d)%6;

 end

 return h

end

--

--

-- ... eof RGB color modifications ...

--

-- ****************************************

-- *** Custom Color / Palette functions ***

-- ****************************************

--# of Unique colors in palette:

--#db.fixPalette(db.makePalList(256))

--# of Colors in Image:

--#db.makePalListFromHistogram(db.makeHistogram())

--# of Unique colors in Image:

--#db.fixPalette(db.makePalListFromHistogram(db.makeHistogram()))

--

function db.rgbcap(r,g,b,mx,mi)

 local m = math

 return m.max(mi,m.min(r,mx)), m.max(mi,m.min(g,mx)), m.max(mi,m.min(b,mx))

end

--

--

function db.rgbcapInt(r,g,b,mx,mi)

 local m = math

 return m.floor(m.max(mi,m.min(r,mx))), m.floor(m.max(mi,m.min(g,mx))), m.floor(m.max(mi,m.min(b,mx)))

end

--

--

function db.makePalList(cols)

 local pal,n,r,g,b

 pal = {}

 for n = 0, cols-1, 1 do

   r,g,b = getcolor(n)

   pal[n+1] = {r,g,b,n}

 end

 return pal

end

--

--

function db.makeSparePalList(cols)

 local pal,n,r,g,b

 pal = {}

 for n = 0, cols-1, 1 do

   r,g,b = getsparecolor(n)

   pal[n+1] = {r,g,b,n}

 end

 return pal

end

--

--

-- Use to remove the black colors (marks unused colors) from palette-list

-- if it's known that no black color exists in the image.

function db.stripBlackFromPalList(pallist)

   local i,u,c,dummy; i = 257 -- Do 'nothing' If using a full 256 col palette with no blacks

   for u = 1, #pallist, 1 do

     c = pallist[u]

     if (c[1]+c[2]+c[3]) == 0 then i = u; end

   end

   dummy = table.remove(pallist,i)

   return pallist

end

--

--

function db.stripIndexFromPalList(pallist,colindex)

   local i,u,c,dummy

   for u = 1, #pallist, 1 do

     c = pallist[u]

     if c[4] == colindex then i = u; end

   end

   dummy = table.remove(pallist,i)

   return pallist

end

--

--

function db.addHSBtoPalette(pallist)

 local n,hue,sat,rgb

 for n=1, #pallist, 1 do

   rgb = pallist[n]

   pallist[n][5] =        db.getHUE(rgb[1],rgb[2],rgb[3],0)

   pallist[n][6] = db.getSaturation(rgb[1],rgb[2],rgb[3])

   pallist[n][7] = db.getBrightness(rgb[1],rgb[2],rgb[3])

 end

 return pallist -- {r,g,b,n,bri,hue,sat}

end

--

--

function db.makePalListRange(start,ends)

 local pal,n,r,g,b,a

 pal = {}

 a = 1

 for n = start, ends, 1 do

   r,g,b = getcolor(n)

   pal[a] = {r,g,b,n}; a = a + 1;

 end

 return pal

end

--

--

function db.makePalListShade(cols,sha) -- Convert colors to less bits, colorcube operations etc.

 local pal,n,r,g,b,mf,div

 mf = math.floor

 div = 256 / sha

 pal = {}