palette_matchers.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <ranges>
#include <set>
 
#include "porytiles/domain/models/palette.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
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;
 
    std::size_t palette_index = 0;
};
 
namespace details {
 
template <SupportsTransparency ColorType, typename TransparencyPredicate, std::size_t N = 0>
[[nodiscard]] PaletteMatchResult<ColorType> match_tile_to_palette_impl(
    const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette, TransparencyPredicate is_transparent_pred)
{
    PaletteMatchResult<ColorType> result;
 
    // Get the palette colors as a set for efficient lookup. We don't include the slot 0 color, since it's irrelevant.
    std::set<ColorType> palette_colors_set;
    for (const auto &color : palette.color_to_index_map() | std::views::keys) {
        palette_colors_set.insert(color);
    }
 
    // 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, std::size_t N = 0>
[[nodiscard]] PaletteMatchResult<ColorType>
match_tile_to_palette(const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette)
    requires requires(const ColorType &c) { c.is_transparent(); }
{
    if (palette.size() == 0) {
        panic("palette is empty");
    }
    return details::match_tile_to_palette_impl(tile, palette, [](const ColorType &c) { return c.is_transparent(); });
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PaletteMatchResult<ColorType> match_tile_to_palette(
    const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette, const ColorType &extrinsic)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    if (palette.size() == 0) {
        panic("palette is empty");
    }
    return details::match_tile_to_palette_impl(
        tile, palette, [&extrinsic](const ColorType &c) { return c.is_transparent(extrinsic); });
}
 
template <SupportsTransparency ColorType, typename PaletteContainer>
[[nodiscard]] std::vector<PaletteMatchResult<ColorType>> match_or_best(
    const PixelTile<ColorType> &tile, const PaletteContainer &palettes, const ColorType &extrinsic, std::size_t top_n)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    if (palettes.empty()) {
        panic("palettes container 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.palette_index = 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 porytiles