Image.lua

local computer = require("computer")
local color = require("color")
local unicode = require("unicode")
local fs = require("filesystem")
local gpu = require("component").gpu

-------------------------------------------------------------------------------

local image = {formatModules = {}}

-------------------------------------------------------------------------------

function image.getIndex(x, y, width)
    return width * (y - 1) + x
end

function image.group(picture, compressColors)
    local groupedPicture, x, y, background, foreground = {}, 1, 1

    for i = 1, #picture[3] do
        if compressColors then
            background, foreground = color.to8Bit(picture[3][i]), color.to8Bit(picture[4][i])
            if i % 603 == 0 then
                computer.pullSignal(0)
            end
        else
            background, foreground = picture[3][i], picture[4][i]
        end

        groupedPicture[picture[5][i]] = groupedPicture[picture[5][i]] or {}
        groupedPicture[picture[5][i]][picture[6][i]] = groupedPicture[picture[5][i]][picture[6][i]] or {}
        groupedPicture[picture[5][i]][picture[6][i]][background] = groupedPicture[picture[5][i]][picture[6][i]][background] or {}
        groupedPicture[picture[5][i]][picture[6][i]][background][foreground] = groupedPicture[picture[5][i]][picture[6][i]][background][foreground] or {}
        groupedPicture[picture[5][i]][picture[6][i]][background][foreground][y] = groupedPicture[picture[5][i]][picture[6][i]][background][foreground][y] or {}

        table.insert(groupedPicture[picture[5][i]][picture[6][i]][background][foreground][y], x)

        x = x + 1
        if x > picture[1] then
            x, y = 1, y + 1
        end
    end

    return groupedPicture
end

function image.draw(x, y, picture)
    local groupedPicture = image.group(picture)
    local _, _, currentBackground, currentForeground, gpuGetBackground, imageX, imageY

    for alpha in pairs(groupedPicture) do
        for symbol in pairs(groupedPicture[alpha]) do

            if not (symbol == " " and alpha == 1) then
                for background in pairs(groupedPicture[alpha][symbol]) do

                    if background ~= currentBackground then
                        currentBackground = background
                        gpu.setBackground(background)
                    end

                    for foreground in pairs(groupedPicture[alpha][symbol][background]) do

                        if foreground ~= currentForeground and symbol ~= " " then
                            currentForeground = foreground
                            gpu.setForeground(foreground)
                        end

                        for yPos in pairs(groupedPicture[alpha][symbol][background][foreground]) do
                            for xPos = 1, #groupedPicture[alpha][symbol][background][foreground][yPos] do
                                imageX, imageY = x + groupedPicture[alpha][symbol][background][foreground][yPos][xPos] - 1, y + yPos - 1

                                if alpha > 0 then
                                    _, _, gpuGetBackground = gpu.get(imageX, imageY)

                                    if alpha == 1 then
                                        currentBackground = gpuGetBackground
                                        gpu.setBackground(currentBackground)
                                    else
                                        currentBackground = color.blend(gpuGetBackground, background, alpha)
                                        gpu.setBackground(currentBackground)
                                    end
                                end

                                gpu.set(imageX, imageY, symbol)
                            end
                        end
                    end
                end
            end
        end
    end
end

function image.create(width, height, background, foreground, alpha, symbol, random)
    local picture = {width, height, {}, {}, {}, {}}

    for i = 1, width * height do
        table.insert(picture[3], random and math.random(0x0, 0xFFFFFF) or (background or 0x0))
        table.insert(picture[4], random and math.random(0x0, 0xFFFFFF) or (foreground or 0x0))
        table.insert(picture[5], alpha or 0x0)
        table.insert(picture[6], random and string.char(math.random(65, 90)) or (symbol or " "))
    end

    return picture
end

function image.copy(picture)
    local newPicture = {picture[1], picture[2], {}, {}, {}, {}}

    for i = 1, #picture[3] do
        newPicture[3][i] = picture[3][i]
        newPicture[4][i] = picture[4][i]
        newPicture[5][i] = picture[5][i]
        newPicture[6][i] = picture[6][i]
    end

    return newPicture
end

-------------------------------------------------------------------------------

function image.loadFormatModule(path, extension)
    local success, result = loadfile(path)
    if success then
        success, result = pcall(success, image)
        if success then
            image.formatModules[extension] = result
        else
            error("Failed to execute image format module: " .. tostring(result))
        end
    else
        error("Failed to load image format module: " .. tostring(result))
    end
end

local function loadOrSave(methodName, path, ...)
    local extension = fs.extension(path)
    if image.formatModules[extension] then
        local success, result = pcall(image.formatModules[extension][methodName], path, ...)
        if success then
            return result
        else
            return false, "Failed to " .. methodName .. " image file: " .. tostring(result)
        end
    else
        return false, "Failed to " .. methodName .. " image file: format module for extension \"" .. tostring(extension) .. "\" is not loaded"
    end
end

function image.save(path, picture, encodingMethod)
    return loadOrSave("save", path, picture, encodingMethod)
end

function image.load(path)
    return loadOrSave("load", path)
end

-------------------------------------------------------------------------------

function image.toString(picture)
    local charArray = {
        string.format("%02X", picture[1]),
        string.format("%02X", picture[2])
    }

    for i = 1, #picture[3] do
        table.insert(charArray, string.format("%02X", color.to8Bit(picture[3][i])))
        table.insert(charArray, string.format("%02X", color.to8Bit(picture[4][i])))
        table.insert(charArray, string.format("%02X", math.floor(picture[5][i] * 255)))
        table.insert(charArray, picture[6][i])

        if i % 603 == 0 then
            computer.pullSignal(0)
        end
    end

    return table.concat(charArray)
end

function image.fromString(pictureString)
    local picture = {
        tonumber("0x" .. unicode.sub(pictureString, 1, 2)),
        tonumber("0x" .. unicode.sub(pictureString, 3, 4)),
        {}, {}, {}, {}
    }

    for i = 5, unicode.len(pictureString), 7 do
        table.insert(picture[3], color.to24Bit(tonumber("0x" .. unicode.sub(pictureString, i, i + 1))))
        table.insert(picture[4], color.to24Bit(tonumber("0x" .. unicode.sub(pictureString, i + 2, i + 3))))
        table.insert(picture[5], tonumber("0x" .. unicode.sub(pictureString, i + 4, i + 5)) / 255)
        table.insert(picture[6], unicode.sub(pictureString, i + 6, i + 6))
    end

    return picture
end

-------------------------------------------------------------------------------

function image.set(picture, x, y, background, foreground, alpha, symbol)
    local index = image.getIndex(x, y, picture[1])
    picture[3][index], picture[4][index], picture[5][index], picture[6][index] = background, foreground, alpha, symbol

    return picture
end

function image.get(picture, x, y)
    local index = image.getIndex(x, y, picture[1])
    return picture[3][index], picture[4][index], picture[5][index], picture[6][index]
end

function image.getSize(picture)
    return picture[1], picture[2]
end

function image.getWidth(picture)
    return picture[1]
end

function image.getHeight(picture)
    return picture[2]
end

function image.transform(picture, newWidth, newHeight)
    local newPicture, stepWidth, stepHeight, background, foreground, alpha, symbol = {newWidth, newHeight, {}, {}, {}, {}}, picture[1] / newWidth, picture[2] / newHeight

    local x, y = 1, 1
    for j = 1, newHeight do
        for i = 1, newWidth do
            background, foreground, alpha, symbol = image.get(picture, math.floor(x), math.floor(y))
            table.insert(newPicture[3], background)
            table.insert(newPicture[4], foreground)
            table.insert(newPicture[5], alpha)
            table.insert(newPicture[6], symbol)

            x = x + stepWidth
        end

        x, y = 1, y + stepHeight
    end

    return newPicture
end

function image.crop(picture, fromX, fromY, width, height)
    if fromX >= 1 and fromY >= 1 and fromX + width - 1 <= picture[1] and fromY + height - 1 <= picture[2] then
        local newPicture, background, foreground, alpha, symbol = {width, height, {}, {}, {}, {}}

        for y = fromY, fromY + height - 1 do
            for x = fromX, fromX + width - 1 do
                background, foreground, alpha, symbol = image.get(picture, x, y)
                table.insert(newPicture[3], background)
                table.insert(newPicture[4], foreground)
                table.insert(newPicture[5], alpha)
                table.insert(newPicture[6], symbol)
            end
        end

        return newPicture
    else
        return false, "Failed to crop image: target coordinates are out of source range"
    end
end

function image.flipHorizontally(picture)
    local newPicture, background, foreground, alpha, symbol = {picture[1], picture[2], {}, {}, {}, {}}

    for y = 1, picture[2] do
        for x = picture[1], 1, -1 do
            background, foreground, alpha, symbol = image.get(picture, x, y)
            table.insert(newPicture[3], background)
            table.insert(newPicture[4], foreground)
            table.insert(newPicture[5], alpha)
            table.insert(newPicture[6], symbol)
        end
    end

    return newPicture
end

function image.flipVertically(picture)
    local newPicture, background, foreground, alpha, symbol = {picture[1], picture[2], {}, {}, {}, {}}

    for y = picture[2], 1, -1 do
        for x = 1, picture[1] do
            background, foreground, alpha, symbol = image.get(picture, x, y)
            table.insert(newPicture[3], background)
            table.insert(newPicture[4], foreground)
            table.insert(newPicture[5], alpha)
            table.insert(newPicture[6], symbol)
        end
    end

    return newPicture
end

function image.expand(picture, fromTop, fromBottom, fromLeft, fromRight, background, foreground, alpha, symbol)
    local newPicture = image.create(picture[1] + fromRight + fromLeft, picture[2] + fromTop + fromBottom, background, foreground, alpha, symbol)

    for y = 1, picture[2] do
        for x = 1, picture[1] do
            image.set(newPicture, x + fromLeft, y + fromTop, image.get(picture, x, y))
        end
    end

    return newPicture
end

function image.blend(picture, blendColor, transparency)
    local newPicture = {picture[1], picture[2], {}, {}, {}, {}}

    for i = 1, #picture[3] do
        table.insert(newPicture[3], color.blend(picture[3][i], blendColor, transparency))
        table.insert(newPicture[4], color.blend(picture[4][i], blendColor, transparency))
        table.insert(newPicture[5], picture[5][i])
        table.insert(newPicture[6], picture[6][i])
    end

    return newPicture
end

function image.rotate(picture, angle)
    local radAngle = math.rad(angle)
    local sin, cos = math.sin(radAngle), math.cos(radAngle)
    local pixMap = {}

    local xCenter, yCenter = picture[1] / 2, picture[2] / 2
    local xMin, xMax, yMin, yMax = math.huge, -math.huge, math.huge, -math.huge
    for y = 1, picture[2] do
        for x = 1, picture[1] do
            local xNew = math.round(xCenter + (x - xCenter) * cos - (y - yCenter) * sin)
            local yNew = math.round(yCenter + (y - yCenter) * cos + (x - xCenter) * sin)

            xMin, xMax, yMin, yMax = math.min(xMin, xNew), math.max(xMax, xNew), math.min(yMin, yNew), math.max(yMax, yNew)

            pixMap[yNew] = pixMap[yNew] or {}
            pixMap[yNew][xNew] = {image.get(picture, x, y)}
        end
    end

    local newPicture = image.create(xMax - xMin + 1, yMax - yMin + 1, 0xFF0000, 0x0, 0x0, "#")
    for y in pairs(pixMap) do
        for x in pairs(pixMap[y]) do
            image.set(newPicture, x - xMin + 1, y - yMin + 1, pixMap[y][x][1], pixMap[y][x][2], pixMap[y][x][3], pixMap[y][x][4])
        end
    end

    return newPicture
end

-------------------------------------------------------------------------------

image.loadFormatModule("/lib/FormatModules/OCIF.lua", ".pic")

-------------------------------------------------------------------------------

return image