palette_matchers.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <set>
 
#include "porytiles2/domain/models/palette.hpp"
#include "porytiles2/domain/models/pixel_tile.hpp"
#include "porytiles2/xcut/panic/panic.hpp"
 
namespace porytiles2 {
 
template <SupportsTransparency ColorType>
struct PaletteMatchResult {
    bool is_covered = false;
 
    std::set<ColorType> missing_colors;
 
    std::set<ColorType> covered_colors;
 
    std::vector<std::size_t> uncovered_pixel_indices;
 
    unsigned int pal_index = 0;
};
 
namespace details {
 
template <SupportsTransparency ColorType, typename TransparencyPredicate>
[[nodiscard]] PaletteMatchResult<ColorType> match_tile_to_palette_impl(
    const PixelTile<ColorType> &tile, const Palette<ColorType> &palette, TransparencyPredicate is_transparent_pred)
{
    PaletteMatchResult<ColorType> result;
 
    // Get the palette colors as a set for efficient lookup
    const auto &palette_colors_vec = palette.colors();
    std::set<ColorType> palette_colors_set{palette_colors_vec.begin(), palette_colors_vec.end()};
 
    // Extract all unique non-transparent colors from the tile and track uncovered pixels
    std::set<ColorType> tile_colors;
    for (std::size_t i = 0; i < tile::size_pix; ++i) {
        const auto &pixel = tile.at(i);
        if (!is_transparent_pred(pixel)) {
            tile_colors.insert(pixel);
 
            // If this pixel's color is not in the palette, record its index
            if (!palette_colors_set.contains(pixel)) {
                result.uncovered_pixel_indices.push_back(i);
            }
        }
    }
 
    // Categorize each tile color as covered or missing
    for (const auto &color : tile_colors) {
        if (palette_colors_set.contains(color)) {
            result.covered_colors.insert(color);
        }
        else {
            result.missing_colors.insert(color);
        }
    }
 
    // The tile is covered if there are no missing colors
    result.is_covered = result.missing_colors.empty();
 
    return result;
}
 
} // namespace details
 
template <SupportsTransparency ColorType>
[[nodiscard]] PaletteMatchResult<ColorType>
match_tile_to_palette(const PixelTile<ColorType> &tile, const Palette<ColorType> &palette)
    requires requires(const ColorType &c) { c.is_transparent(); }
{
    return details::match_tile_to_palette_impl(tile, palette, [](const ColorType &c) { return c.is_transparent(); });
}
 
template <SupportsTransparency ColorType>
[[nodiscard]] PaletteMatchResult<ColorType>
match_tile_to_palette(const PixelTile<ColorType> &tile, const Palette<ColorType> &palette, const ColorType &extrinsic)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    if (palette.size() == 0) {
        panic("palette is empty");
    }
 
    if (palette.colors().at(0) != extrinsic) {
        // TODO: we should have an earlier compilation step that normalizes transparency in Porymap pals, since
        // their default slot 0 transparency doesn't matter. When you import a vanilla set to Porytiles, all
        // transparent pixels get normalized to the configured extrinsic transparency. During this earlier step, we can
        // warn the user that the slot 0 of their Porymap pal will be overwritten. We can explain in a note that this
        // should not be an issue.
        panic("palette slot 0 did not match provided extrinsic transparency value");
    }
 
    return details::match_tile_to_palette_impl(
        tile, palette, [&extrinsic](const ColorType &c) { return c.is_transparent(extrinsic); });
}
 
template <SupportsTransparency ColorType>
[[nodiscard]] std::vector<PaletteMatchResult<ColorType>> match_or_best(
    const PixelTile<ColorType> &tile,
    const std::vector<Palette<ColorType>> &palettes,
    const ColorType &extrinsic,
    std::size_t top_n)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    if (palettes.empty()) {
        panic("palettes vector is empty");
    }
    if (top_n == 0) {
        panic("top_n must be greater than 0");
    }
 
    // Match tile against all palettes
    std::vector<PaletteMatchResult<ColorType>> complete_matches;
    std::vector<PaletteMatchResult<ColorType>> incomplete_matches;
 
    for (std::size_t i = 0; i < palettes.size(); ++i) {
        auto result = match_tile_to_palette(tile, palettes[i], extrinsic);
        result.pal_index = static_cast<unsigned int>(i);
 
        if (result.is_covered) {
            complete_matches.push_back(result);
        }
        else {
            incomplete_matches.push_back(result);
        }
    }
 
    // If we found any complete matches, return all of them (ignore top_n)
    if (!complete_matches.empty()) {
        return complete_matches;
    }
 
    // No complete matches found, sort incomplete matches by quality (fewer missing_colors is better)
    std::sort(incomplete_matches.begin(), incomplete_matches.end(), [](const auto &a, const auto &b) {
        return a.missing_colors.size() < b.missing_colors.size();
    });
 
    // Return top_n results (or all if fewer than top_n)
    if (incomplete_matches.size() > top_n) {
        incomplete_matches.resize(top_n);
    }
 
    return incomplete_matches;
}
 
} // namespace porytiles2