utils.hpp

Go to the documentation of this file.

#ifndef POPS_UTILS_HPP
#define POPS_UTILS_HPP
 
/*
 * PoPS model - general utility functions (unrelated to the model)
 *
 * Copyright (C) 2020-2021 by the authors.
 *
 * Authors: Vaclav Petras <wenzeslaus gmail com>
 *
 * The code contained herein is licensed under the GNU General Public
 * License. You may obtain a copy of the GNU General Public License
 * Version 2 or later at the following locations:
 *
 * http://www.opensource.org/licenses/gpl-license.html
 * http://www.gnu.org/copyleft/gpl.html
 */
 
#define UNUSED(expr) (void)(expr)
 
#define M_PI 3.14159265358979323846
#define PI M_PI
 
#include <algorithm>
#include <array>
#include <vector>
 
template<typename Container, typename Value>
bool container_contains(const Container& container, const Value& value)
{
    return container.find(value) != container.end();
}
 
// Replace by ranges::shuffle in C++20.
template<typename Container, typename Generator>
void shuffle_container(Container& container, Generator& generator)
{
    std::shuffle(container.begin(), container.end(), generator);
}
 
typedef std::tuple<int, int, int, int> BBoxInt;
typedef std::tuple<double, double, double, double> BBoxFloat;
typedef std::tuple<bool, bool, bool, bool> BBoxBool;
 
// C++20 NumericType
template<typename Number>
struct BBox
{
    Number north;
    Number south;
    Number east;
    Number west;
 
    BBox() : north(0), south(0), east(0), west(0) {}
};
 
enum class Direction
{
    N = 0,  
    NE = 45,  
    E = 90,  
    SE = 135,  
    S = 180,  
    SW = 225,  
    W = 270,  
    NW = 315,  
    None  
};
 
template<int... Indices>
struct indices
{
    using next = indices<Indices..., sizeof...(Indices)>;
};
 
template<int Size>
struct build_indices
{
    using type = typename build_indices<Size - 1>::type::next;
};
 
template<>
struct build_indices<0>
{
    using type = indices<>;
};
 
template<typename T>
using Bare = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
template<typename Tuple>
constexpr typename build_indices<std::tuple_size<Bare<Tuple>>::value>::type
make_indices()
{
    return {};
}
 
template<typename Tuple, int... Indices>
std::array<
    typename std::tuple_element<0, Bare<Tuple>>::type,
    std::tuple_size<Bare<Tuple>>::value>
to_array(Tuple&& tuple, indices<Indices...>)
{
    using std::get;
    return {{get<Indices>(std::forward<Tuple>(tuple))...}};
}
 
template<typename Tuple>
auto to_array(Tuple&& tuple)
    -> decltype(to_array(std::declval<Tuple>(), make_indices<Tuple>()))
{
    return to_array(std::forward<Tuple>(tuple), make_indices<Tuple>());
}
 
std::string quarantine_enum_to_string(Direction type)
{
    switch (type) {
    case Direction::N:
        return "N";
    case Direction::S:
        return "S";
    case Direction::E:
        return "E";
    case Direction::W:
        return "W";
    case Direction::None:
        return "None";
    default:
        return "Invalid direction";
    }
}
 
template<typename RasterIndex, typename RasterType>
std::vector<std::vector<RasterIndex>> find_suitable_cells(const RasterType& raster)
{
    std::vector<std::vector<RasterIndex>> cells;
    // The assumption is that the raster is sparse (otherwise we would not be doing
    // this), so we have no number for the reserve method.
    for (RasterIndex row = 0; row < raster.rows(); ++row) {
        for (RasterIndex col = 0; col < raster.cols(); ++col) {
            if (raster(row, col) > 0) {
                cells.push_back({row, col});
            }
        }
    }
    return cells;
}
 
#endif  // POPS_UTILS_HPP