shape_group_analyzer.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <map>
#include <vector>
 
#include "porytiles/domain/models/canonical_shape_tile.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/models/shape_group.hpp"
#include "porytiles/domain/models/shape_mask.hpp"
#include "porytiles/domain/models/shape_tile.hpp"
#include "porytiles/domain/models/supports_transparency.hpp"
 
namespace porytiles {
 
template <SupportsTransparency PixelType, typename TransparencyPredicate>
[[nodiscard]] ShapeTile<PixelType>
shape_tile_from_pixel_tile(const PixelTile<PixelType> &pixel_tile, TransparencyPredicate is_transparent_pred)
{
    std::map<PixelType, ShapeMask> color_to_mask;
 
    for (std::size_t row = 0; row < tile::side_length_pix; ++row) {
        for (std::size_t col = 0; col < tile::side_length_pix; ++col) {
            const auto pixel = pixel_tile.at(row, col);
            if (is_transparent_pred(pixel)) {
                continue;
            }
            color_to_mask[pixel].set(row, col);
        }
    }
 
    ShapeTile<PixelType> result;
    for (const auto &[color, mask] : color_to_mask) {
        result.set(mask, color);
    }
    return result;
}
 
template <SupportsTransparency PixelType>
[[nodiscard]] std::vector<ShapeGroup<PixelType>>
analyze_shape_groups(const std::vector<PixelTile<PixelType>> &tiles, const PixelType &extrinsic)
    requires requires(const PixelType &c) { c.is_transparent(c); }
{
    // Use a comparator that compares ShapeTiles by shape only (ignoring pixel values). This groups tiles with
    // the same geometric structure regardless of their color assignments.
    auto shape_only_less = [](const ShapeTile<PixelType> &a, const ShapeTile<PixelType> &b) {
        return ShapeTile<PixelType>::compare_shape_only(a, b);
    };
 
    // Map canonical shape (by geometry only) -> list of members
    std::map<ShapeTile<PixelType>, std::vector<ShapeGroupMember<PixelType>>, decltype(shape_only_less)> groups(
        shape_only_less);
 
    for (std::size_t i = 0; i < tiles.size(); ++i) {
        auto shape_tile = shape_tile_from_pixel_tile(
            tiles[i], [&extrinsic](const PixelType &c) { return c.is_transparent(extrinsic); });
 
        // Skip fully transparent tiles
        if (shape_tile.is_transparent()) {
            continue;
        }
 
        CanonicalShapeTile<PixelType> canonical{shape_tile};
 
        ShapeGroupMember<PixelType> member;
        member.tile_index = i;
        member.colors = canonical.colors();
        member.h_flip = canonical.h_flip();
        member.v_flip = canonical.v_flip();
 
        // Use the canonical form (as ShapeTile) as the grouping key
        groups[static_cast<const ShapeTile<PixelType> &>(canonical)].push_back(std::move(member));
    }
 
    // Filter to groups with 2+ members that have distinct color assignments
    std::vector<ShapeGroup<PixelType>> result;
    for (auto &[canonical_shape, members] : groups) {
        if (members.size() < 2) {
            continue;
        }
 
        // Check if there are at least 2 distinct color assignments
        bool has_distinct_colors = false;
        for (std::size_t j = 1; j < members.size(); ++j) {
            if (members[j].colors != members[0].colors) {
                has_distinct_colors = true;
                break;
            }
        }
 
        if (!has_distinct_colors) {
            continue;
        }
 
        ShapeGroup<PixelType> group;
        group.canonical_shape = canonical_shape;
        group.members = std::move(members);
        result.push_back(std::move(group));
    }
 
    return result;
}
 
} // namespace porytiles