math_polygon2.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_MATH_POLYGON2_H_
#define DESIGNLAB_MATH_POLYGON2_H_
 
#include <array>
#include <optional>
#include <string>
#include <vector>
 
#include "cassert_define.h"
#include "math_vector2.h"
 
 
namespace designlab
{
 
struct Polygon2 final
{
    constexpr Polygon2() : vertex_num(0)
    {
    }
 
    explicit Polygon2(const std::vector<Vector2>& vertex);
 
 
    constexpr void AddVertex(const Vector2& v)
    {
        vertex[static_cast<size_t>(vertex_num)] = v;
        ++vertex_num;
 
        assert(vertex_num <= kMaxVertexNum);  // 頂点数は最大値を超えてはいけない．
    }
 
    bool AddVertexCheckForDuplicates(const Vector2& v);
 
 
    void RemoveVertex(const int index);
 
    constexpr void RemoveLastVertex()
    {
        if (GetVertexNum() == 0)
        {
            return;
        }
 
        --vertex_num;
    }
 
    constexpr void Reset()
    {
        vertex_num = 0;
    }
 
    constexpr int GetVertexNum() const
    {
        return vertex_num;
    }
 
    constexpr Vector2 GetVertex(const int i) const
    {
        if (i < 0 || i >= GetVertexNum())
        {
            return Vector2{ 0, 0 };
        }
 
        return vertex[static_cast<size_t>(i)];
    }
 
    constexpr std::optional<Vector2> GetVertexOpt(const int i) const
    {
        if (i < 0 || i >= GetVertexNum())
        {
            return std::nullopt;
        }
 
        return vertex[static_cast<size_t>(i)];
    }
 
    constexpr float GetMaxX() const
    {
        float max_x = vertex[0].x;
 
        for (int i = 1; i < GetVertexNum(); ++i)
        {
            max_x = (std::max)(max_x, vertex[static_cast<size_t>(i)].x);
        }
 
        return max_x;
    }
 
    constexpr float GetMinX() const
    {
        float min_x = vertex[0].x;
 
        for (int i = 1; i < GetVertexNum(); ++i)
        {
            min_x = (std::min)(min_x, vertex[static_cast<size_t>(i)].x);
        }
 
        return min_x;
    }
 
    constexpr float GetMaxY() const
    {
        float max_y = vertex[0].y;
 
        for (int i = 1; i < GetVertexNum(); ++i)
        {
            max_y = (std::max)(max_y, vertex[static_cast<size_t>(i)].y);
        }
 
        return max_y;
    }
 
    constexpr float GetMinY() const
    {
        float min_y = vertex[0].y;
 
        for (int i = 1; i < GetVertexNum(); ++i)
        {
            min_y = (std::min)(min_y, vertex[static_cast<size_t>(i)].y);
        }
 
        return min_y;
    }
 
    bool IsConvex() const;
 
    bool IsInside(const Vector2& point) const;
 
 
    std::string ToString() const;
 
private:
    static constexpr int kMaxVertexNum = 6;
 
    std::array<Vector2, kMaxVertexNum> vertex;  
 
    int vertex_num;  
};
 
 
template <class Char>
inline std::basic_ostream<Char>& operator <<(
    std::basic_ostream<Char>& os, const Polygon2& poly)
{
    os << poly.ToString();
 
    return os;
}
 
}  // namespace designlab
 
 
#endif  // DESIGNLAB_MATH_POLYGON2_H_