tile_extractors.hpp

Go to the documentation of this file.

#pragma once
 
#include <format>
#include <vector>
 
#include "porytiles/domain/models/image.hpp"
#include "porytiles/domain/models/metatile.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
template <typename PixelType>
[[nodiscard]] std::vector<PixelTile<PixelType>> extract_tiles_from_image(
    const Image<PixelType> &img, std::size_t tile_offset, std::size_t tile_count, std::size_t tiles_per_row = 16)
{
    if (img.width() % tile::side_length_pix != 0 || img.height() % tile::side_length_pix != 0) {
        panic(
            std::format(
                "image dimensions must be multiples of {}, got {}x{}",
                tile::side_length_pix,
                img.width(),
                img.height()));
    }
 
    std::vector<PixelTile<PixelType>> result;
    result.reserve(tile_count);
 
    for (std::size_t i = 0; i < tile_count; ++i) {
        const std::size_t tile_idx = tile_offset + i;
        const std::size_t tile_row = tile_idx / tiles_per_row;
        const std::size_t tile_col = tile_idx % tiles_per_row;
 
        const std::size_t pixel_x = tile_col * tile::side_length_pix;
        const std::size_t pixel_y = tile_row * tile::side_length_pix;
 
        PixelTile<PixelType> pixel_tile;
        for (std::size_t row = 0; row < tile::side_length_pix; ++row) {
            for (std::size_t col = 0; col < tile::side_length_pix; ++col) {
                pixel_tile.set(row, col, img.at(pixel_y + row, pixel_x + col));
            }
        }
 
        result.push_back(std::move(pixel_tile));
    }
 
    return result;
}
 
template <typename PixelType>
[[nodiscard]] std::vector<PixelTile<PixelType>> extract_tiles_from_image(const Image<PixelType> &img)
{
    if (img.width() % tile::side_length_pix != 0 || img.height() % tile::side_length_pix != 0) {
        panic(
            std::format(
                "image dimensions must be multiples of {}, got {}x{}",
                tile::side_length_pix,
                img.width(),
                img.height()));
    }
 
    const std::size_t tiles_per_row = img.width() / tile::side_length_pix;
    const std::size_t total_tiles = img.size_in_tiles();
 
    return extract_tiles_from_image(img, 0, total_tiles, tiles_per_row);
}
 
template <typename PixelType>
[[nodiscard]] PixelTile<PixelType> extract_single_tile(
    const Image<PixelType> &img,
    std::size_t tile_idx,
    std::size_t tiles_per_row = metatile::metatiles_per_row * metatile::tiles_per_side)
{
    return extract_tiles_from_image(img, tile_idx, 1, tiles_per_row).at(0);
}
 
} // namespace porytiles