PIX.lua

local shl = require("shell")
local com = require("computer")
local cmp = require("component")
local uni = require("unicode")
local trm = require("term")
local gpu = cmp.gpu
local args = shl.parse(...)
local sym = {"▄", "▀", "█", " "}

BYTE = 0

function ItoB(integer, byte)
  local str = ""
  for i = 1, byte do
    str = string.char(integer % 256)..str
    integer = bit32.rshift(integer, 8)
  end
  return str
end

function BtoI(str)
  local integer = 0
  for i=1, string.len(str) do
    integer = bit32.lshift(integer, 8)  + string.byte(str, i)
  end
  return integer
end

local function getMF(x, y, w, h)
  local m = {}
  local clr = {}
  local max = {"one", "two"}
  local f, b

  for i = x, x + w - 1 do
    m[i] = {}
    for j = y, y + h - 1 do
      _, f, b, _, _ = gpu.get(i, j)
      m[i][j] = { f, b }
      if clr[m[i][j][1]] == nil then
        clr[m[i][j][1]] = {}
      end
      if clr[m[i][j][1]][m[i][j][2]] == nil then
        clr[m[i][j][1]][m[i][j][2]] = 0
      end
      clr[m[i][j][1]][m[i][j][2]] = clr[m[i][j][1]][m[i][j][2]] + 1
    end
  end

  clr["one"] = {}
  clr["one"]["two"] = 0

  for i, _ in pairs(clr) do
    for j, _ in pairs(clr[i]) do
      if clr[max[1]][max[2]] < clr[i][j] then
        max = {i, j}
      end
    end
  end

  local matrix = {}

  for i, _ in pairs(m) do
    for j, _ in pairs(m[i]) do
      if m[i][j][1] ~= max[1] or m[i][j][2] ~= max[2] then
        if matrix[j] == nil then
          matrix[j] = {}
        end
        matrix[j][i] = m[i][j]
      end
    end
  end

  return matrix, {w, h, max[1], max[2]}
end

function isLine(x, y)
  if y ~= nil and (x[1] == y[1] and x[2] == y[2] or x[1] == y[2] and x[2] == y[1] or y[1] == y[2] and (x[1] == y[1] or x[2] == y[1])) then
    return true
  end
  return false
end

function getSym(x, y, s)
  if x[1] == y[1] and x[2] == y[2] then
    return sym[s[1]]
  elseif y[1] == y[2] then
    if x[1] == y[1] then
      return sym[s[1] + 2]
    else
      return sym[5 - s[1]]
    end
  else
    return sym[s[2]]
  end
end

local function getC(m)
  local clr = {}
  local f, b, s
  local ind
  local flag

  for i, _ in pairs(m) do
    for j, _ in pairs(m[i]) do
      f, b = m[i][j][1], m[i][j][2]
      if clr[b] ~= nil and clr[b][f] ~= nil then
        f, b = b, f
        s = {2, 1}
      else
        if clr[f] == nil then
          clr[f] = {}
        end
        if clr[f][b] == nil then
          clr[f][b] = {}
        end
        s = {1, 2}
      end

      flag = false
      ind = #clr[f][b] + 1

      if isLine(m[i][j], m[i][j-1]) then
        clr[f][b][ind] = {j, i, sym[s[1]]}
        local k = j - 1

        while isLine(m[i][j], m[i][k-1]) do
          clr[f][b][ind][3] = getSym(m[i][j], m[i][k], s)..clr[f][b][ind][3]
          m[i][k] = nil
          clr[f][b][ind][1] = clr[f][b][ind][1] - 1
          k = k - 1
        end

        clr[f][b][ind][1] = clr[f][b][ind][1] - 1
        clr[f][b][ind][3] = getSym(m[i][j], m[i][k], s)..clr[f][b][ind][3]
        m[i][k] = nil
        flag = true
      end


      if isLine(m[i][j], m[i][j+1]) then
        if clr[f][b][ind] == nil then
          clr[f][b][ind] = {j, i, sym[s[1]]}
        end
        local k = j + 1

        while isLine(m[i][j], m[i][k+1]) do
          clr[f][b][ind][3] = clr[f][b][ind][3]..getSym(m[i][j], m[i][k], s)
          m[i][k] = nil
          k = k + 1
        end

        clr[f][b][ind][3] = clr[f][b][ind][3]..getSym(m[i][j], m[i][k], s)
        m[i][k] = nil
        flag = true
     end
      if flag then
        m[i][j] = nil
      end
    end
  end

  for i, _ in pairs(m) do
    for j, _ in pairs(m[i]) do
      f, b = m[i][j][1], m[i][j][2]
      if f == b  then
        if clr[f] ~= nil then
          local k, val = pairs(clr[f])
          local key, _ = k(val)
          clr[f][key][#clr[f][key] + 1] = {j, i, sym[3]}
        else
          clr[f] = {}
          clr[f][b] = {}
          clr[f][b][1] = {j, i, sym[3]}
        end
      elseif clr[b] ~= nil and clr[b][f] ~= nil then
        clr[b][f][#clr[b][f] + 1] = {j, i, sym[2]}
      else
        if clr[f] == nil then
          clr[f] = {}
        end
        if clr[f][b] == nil then
          clr[f][b] = {}
        end
        clr[f][b][#clr[f][b] + 1] = {j, i, sym[1]}
      end
    end
  end

  for i, _ in pairs(clr) do
    for j, _ in pairs(clr[i]) do
      if #clr[i][j] == {} then
        clr[i][j] = nil
      end
    end
    if #clr[i] == {} then
      clr[i] = nil
    end
  end

  return clr
end


function codePIX(x, y, w, h)
  local matrix, fone = getMF(x, y, w, h)

  local clr = getC(matrix)

  file = io.open("tresh.PIX", "wb")

  file:write(ItoB(fone[1], 1)..ItoB(fone[2], 1)..ItoB(fone[3], 3)..ItoB(fone[4], 3)..ItoB(#clr, 2))
  s(1 + 1 + 3 + 3 + 2)
  for i, _ in pairs(clr) do
    file:write(ItoB(i, 3)..ItoB(#clr[i], 2))
    s(3 + 2)
    for j, _ in pairs(clr[i]) do
      file:write(ItoB(j, 3)..ItoB(#clr[i][j], 2))
      s(3 + 2)
      for k, _ in pairs(clr[i][j]) do
        file:write(ItoB(clr[i][j][k][1], 1)..ItoB(clr[i][j][k][2], 1)..ItoB(#clr[i][j][k][3], 1))
        s(1 + 1 + 1 + math.ceil(#clr[i][j][k][3] / 4))
        local ind = 0
        for l=1, #clr[i][j][k][3] do
          for ij=1, #sym do
            if uni.sub(#clr[i][j][k][3], l, l) == sym[ij] then
              ind = ind + ij - 1
            end
          end
        end
        file:write(ItoB(ind, math.ceil(#clr[i][j][k][3] / 4)))
      end
    end
  end

  file:close()

  return fone, clr
end

function s(n)
  BYTE = BYTE + n
end

function drawPIX(fone, clr)
  shl.execute("b")
  shl.execute("cls")
  time = com.uptime()
  gpu.setForeground(fone[3])
  gpu.setBackground(fone[4])
  gpu.fill(1,1,fone[1],fone[2], "▄")
  for i, _ in pairs(clr) do
    gpu.setForeground(i)
    for j, _ in pairs(clr[i]) do
      gpu.setBackground(j)
      for k, _ in pairs(clr[i][j]) do
        gpu.set(clr[i][j][k][1], clr[i][j][k][2], clr[i][j][k][3])
      end
    end
  end
  time = com.uptime() - time
  gpu.setForeground(0xffffff)
  gpu.setBackground(0x000000)
  print(time)
  print(BYTE / 1024)
end




drawPIX(codePIX(tonumber(args[1]), tonumber(args[2]), tonumber(args[3]), tonumber(args[4])))