color_index_map.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <optional>
#include <vector>
 
#include "porytiles2/domain/models/color_index.hpp"
#include "porytiles2/domain/models/pixel_tile.hpp"
#include "porytiles2/domain/models/supports_transparency.hpp"
 
namespace porytiles2 {
 
template <SupportsTransparency PixelType>
class ColorIndexMap {
  public:
    ColorIndexMap() = default;
 
    ColorIndexMap(const std::vector<PixelTile<PixelType>> &tiles)
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        constructor_impl(tiles, [](const PixelTile<PixelType> &tile) { return tile.unique_nontransparent_colors(); });
    }
 
    ColorIndexMap(const std::vector<PixelTile<PixelType>> &tiles, const PixelType &extrinsic)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        constructor_impl(tiles, [&extrinsic](const PixelTile<PixelType> &tile) {
            return tile.unique_nontransparent_colors(extrinsic);
        });
    }
 
    [[nodiscard]] std::size_t size() const
    {
        return index_map_.size();
    }
 
    [[nodiscard]] bool empty() const
    {
        return size() == 0;
    }
 
    [[nodiscard]] std::optional<PixelType> color_at_index(ColorIndex index) const
    {
        auto it = color_map_.find(index);
        if (it != color_map_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
 
    [[nodiscard]] std::optional<ColorIndex> index_at_color(const PixelType &color) const
    {
        auto it = index_map_.find(color);
        if (it != index_map_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
 
  private:
    template <typename ColorExtractor>
    void constructor_impl(const std::vector<PixelTile<PixelType>> &tiles, ColorExtractor extract_colors)
    {
        std::map<PixelType, ColorIndex> pixel_indexes{};
        std::map<ColorIndex, PixelType> index_to_color{};
 
        unsigned int color_index = 0;
        for (const auto &tile : tiles) {
            for (const auto &pixel : extract_colors(tile)) {
                if (pixel_indexes.insert({pixel, ColorIndex{color_index}}).second) {
                    index_to_color.insert({ColorIndex{color_index}, pixel});
                    color_index++;
                }
            }
        }
 
        index_map_ = pixel_indexes;
        color_map_ = index_to_color;
    }
 
    std::map<PixelType, ColorIndex> index_map_;
    std::map<ColorIndex, PixelType> color_map_;
};
 
} // namespace porytiles2