-- bayer4_to8.lua : converts an image into BM16
-- mode for thomson machines (MO6,TO8,TO9,TO9+)
-- using bayer matrix and a special palette.
--
-- Version: 02-jan-2017
--
-- Copyright 2016-2017 by Samuel Devulder
--
-- This program is free software; you can redistribute
-- it and/or modify it under the terms of the GNU
-- General Public License as published by the Free
-- Software Foundation; version 2 of the License.
-- See <http://www.gnu.org/licenses/>

-- This is my first code in lua, so excuse any bad
-- coding practice.

-- use a zig zag. If false (recommended value), this gives 
-- a raster look and feel
local with_zig_zag = with_zig_zag or false

-- debug: displays histograms
local debug = false

-- enhance luminosity since our mode divide it by two
local enhance_lum = enhance_lum or true

-- use fixed levels (default=false, give better result)
local fixed_levels = fixed_levels or false

-- use void-and-cluster 8x8 matrix (default=false)
local use_vac = use_vac or false

-- get screen size
local screen_w, screen_h = getpicturesize()

run("lib/thomson.lua")
run("lib/color.lua")
run("lib/bayer.lua")

-- Converts thomson coordinates (0-159,0-99) into screen coordinates
local function thom2screen(x,y)
	local i,j;
	if screen_w/screen_h < 1.6 then
		i = x*screen_h/100
		j = y*screen_h/100
	else
		i = x*screen_w/160
		j = y*screen_w/160
	end
	return math.floor(i), math.floor(j)
end

-- return the pixel @(x,y) in linear space corresonding to the thomson screen (x in 0-159, y in 0-99)
local function getLinearPixel(x,y)
	local x1,y1 = thom2screen(x,y)
	local x2,y2 = thom2screen(x+1,y+1)
	if x2==x1 then x2=x1+1 end
	if y2==y1 then y2=y1+1 end

	local p,i,j = Color:new(0,0,0);
	for i=x1,x2-1 do
		for j=y1,y2-1 do
			p:add(getLinearPictureColor(i,j))
		end
	end

	return p:div((y2-y1)*(x2-x1)):floor()
end

--[[ make a bayer matrix
function bayer(matrix)
	local m,n=#matrix,#matrix[1]
	local r,i,j = {}
	for j=1,m*2 do
		local t = {}
		for i=1,n*2 do t[i]=0; end
		r[j] = t;
	end
	
	-- 0 3
	-- 2 1
	for j=1,m do
		for i=1,n do
			local v = 4*matrix[j][i]
			r[m*0+j][n*0+i] = v-3
			r[m*1+j][n*1+i] = v-2
			r[m*1+j][n*0+i] = v-1
			r[m*0+j][n*1+i] = v-0
		end
	end
	
	return r;
end
--]]

-- dither matrix
local dither = bayer.make(4)

if use_vac then
	-- vac8: looks like FS
	dither = bayer.norm{
		{35,57,19,55,7,51,4,21},
		{29,6,41,27,37,17,59,45},
		{61,15,53,12,62,25,33,9},
		{23,39,31,49,2,47,13,43},
		{3,52,8,22,36,58,20,56},
		{38,18,60,46,30,5,42,28},
		{63,26,34,11,64,16,54,10},
		{14,48,1,44,24,40,32,50}
	}
end

-- get color statistics
local stat = {};
function stat:clear() 
	self.r = {}
	self.g = {}
	self.b = {}
	for i=1,16 do self.r[i] = 0; self.g[i] = 0; self.b[i] = 0; end
end
function stat:update(px) 
	local pc2to = thomson.levels.pc2to
	local r,g,b=pc2to[px.r], pc2to[px.g], pc2to[px.b];
	self.r[r] = self.r[r] + 1;
	self.g[g] = self.g[g] + 1;
	self.b[b] = self.b[b] + 1;
end
function stat:coversThr(perc)
	local function f(stat)
		local t=-stat[1]
		for i,n in ipairs(stat) do t=t+n end
		local thr = t*perc; t=-stat[1]
		for i,n in ipairs(stat) do 
			t=t+n 
			if t>=thr then return i end
		end
		return 0
	end
	return f(self.r),f(self.g),f(self.b)
end
stat:clear();
for y = 0,99 do
	for x = 0,159 do
		stat:update(getLinearPixel(x,y))
	end
	thomson.info("Collecting stats...",y,"%")
end

-- enhance luminosity since our mode divide it by two
local gain = 1
if enhance_lum then
	-- findout level that covers 98% of all non-black pixels
	local max = math.max(stat:coversThr(.98))

	gain = math.min(2,255/thomson.levels.linear[max])

	if gain>1 then
		-- redo stat with enhanced levels
		-- messagebox('gain '..gain..' '..table.concat({stat:coversThr(.98)},','))
		stat:clear();
		for y = 0,99 do
			for x = 0,159 do
				stat:update(getLinearPixel(x,y):mul(gain):floor())
			end
			thomson.info("Enhancing levels..",y,"%")
		end
	end
end

-- find regularly spaced levels in thomson space
local levels = {}
function levels.compute(name, stat, num)
	local tot, max = -stat[1],0;
	for _,t in ipairs(stat) do
		max = math.max(t,max)
		tot = tot + t
	end	
	local acc,full=-stat[1],0
	for i,t in ipairs(stat) do
		acc = acc + t
		if acc>tot*.98 then
			full=thomson.levels.linear[i]
			break
		end
	end	
	-- sanity
	if fixed_levels or full==0 then full=255 end
	local res = {1}; num = num-1
	for i=1,num do
		local p = math.floor(full*i/num)
		local q = thomson.levels.linear2to[p]
		if q==res[i] and q<16 then q=q+1 end			
		if not fixed_levels and i<num then
			if q>res[i]+1 and stat[q-1]>stat[q] then q=q-1 end
			if q>res[i]+1 and stat[q-1]>stat[q] then q=q-1 end
			-- 3 corrections? no need...
			-- if q>res[i]+1 and stat[q-1]>stat[q] then q=q-1 end
		end
		res[1+i] = q
	end
	
	-- debug
	if debug then
		local txt = ""
		for _,i in ipairs(res) do
			txt = txt .. i .. " "
		end
		for i,t in ipairs(stat) do
			txt = txt .. "\n" .. string.format("%s%2d:%3d%% ", name, i, math.floor(100*t/(tot+stat[1]))) .. string.rep('X', math.floor(23*t/max))
		end
		messagebox(txt)
	end
	
	return res
end
function levels.computeAll(stat)
	levels.grn = levels.compute("GRN",stat.g,5)
	levels.red = levels.compute("RED",stat.r,4)
	levels.blu = levels.compute("BLU",stat.b,3)
end
levels.computeAll(stat)

-- put a pixel at (x,y) with dithering
local function pset(x,y,px)
	local thr = dither[1+(y % #dither)][1+(x % #dither[1])]
	local function dither(val,thr,lvls)
		local i=#lvls
		local a,b = thomson.levels.linear[lvls[i]],1e30
		while i>1 and val<a do 
			i=i-1;
			a,b=thomson.levels.linear[lvls[i]],a; 
		end
		return i + ((val-a)>=thr*(b-a) and 0 or -1)
	end

	local r = dither(px.r, thr, levels.red);
	local g = dither(px.g, thr, levels.grn);
	local b = dither(px.b, thr, levels.blu);
	
	local i = r + b*4
	local j = g==0 and 0 or (11 + g)
	
	if with_zig_zag and x%2==1 then
		thomson.pset(x,y*2+0,j)
		thomson.pset(x,y*2+1,i)
	else
		thomson.pset(x,y*2+0,i)
		thomson.pset(x,y*2+1,j)
	end
end

-- BM16 mode
thomson.setBM16()

-- define palette
for i=0,15 do
	local r,g,b=0,0,0
	if i<12 then
		-- r = bit32.band(i,3)
		-- b = bit32.rshift(i,2)
		b = math.floor(i/4)
		r = i-4*b
	else
		g = i-11
	end
	r,g,b=levels.red[r+1],levels.grn[g+1],levels.blu[b+1]
	thomson.palette(i,b*256+g*16+r-273)
end

-- convert picture
for y = 0,99 do
	for x = 0,159 do
		pset(x,y, getLinearPixel(x,y):mul(gain):floor())
	end
	thomson.info("Converting...",y,"%")
end

-- refresh screen
setpicturesize(320,200)
thomson.updatescreen()
finalizepicture()

-- save picture
do
	local function exist(file)
		local f=io.open(file,'rb')
		if not f then return false else io.close(f); return true; end
	end
	local name,path = getfilename()
	local mapname = string.gsub(name,"%.%w*$","") .. ".map"
	local fullname = path .. '/' .. mapname
	-- fullname = 'D:/tmp/toto.map'
	local ok = not exist(fullname)
	if not ok then
		selectbox("Ovr " .. mapname .. "?", "Yes", function() ok = true; end, "No", function() ok = false; end)
	end
	if ok then thomson.savep(fullname) end
end
