dl_align.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include <string_view>
 
#include "base/dl_concept.h"
#include "io/dl_log.h"
#include "base/dl_string.h"

namespace dl::Align
{
enum class Direction : int
{
    BACK = -1,
    ZERO = 0,
    FRONT = 1,
    FARTHEST = std::numeric_limits<int>::lowest()
};
 
using Direction2 = Array<Direction, 2>;
 
constexpr Direction2 LT = { Direction::BACK, Direction::BACK };
constexpr Direction2 LC = { Direction::BACK, Direction::ZERO };
constexpr Direction2 LB = { Direction::BACK, Direction::FRONT };
 
constexpr Direction2 CT = { Direction::ZERO, Direction::BACK };
constexpr Direction2 CC = { Direction::ZERO, Direction::ZERO };
constexpr Direction2 CB = { Direction::ZERO, Direction::FRONT };
 
constexpr Direction2 RT = { Direction::FRONT, Direction::BACK };
constexpr Direction2 RC = { Direction::FRONT, Direction::ZERO };
constexpr Direction2 RB = { Direction::FRONT, Direction::FRONT };
 
enum class Dir4
{
    RIGHT = 0,
    BOTTOM,
    LEFT,
    TOP
};
 
enum class Dir8
{
    RIGHT = 0,
    RB,
    BOTTOM,
    LB,
    LEFT,
    LT,
    TOP,
    RT,
    NONE
};

constexpr Dir8 GetDir8(const PointU& p0, const PointU& p1)
{
    // 用“绝对距离 + 符号”判断，而不是 p0.x + 1 == p1.x：
    // PointU 是无符号，加法在哨兵坐标 (unsigned)-1 上会回绕，
    // 把相距极远的两个点误判成相邻。
    const unsigned dx_abs = (p1.x > p0.x) ? (p1.x - p0.x) : (p0.x - p1.x);
    const unsigned dy_abs = (p1.y > p0.y) ? (p1.y - p0.y) : (p0.y - p1.y);
    if (dx_abs > 1 || dy_abs > 1)
        return Dir8::NONE;    // 同一格或不相邻
 
    const int dx = (p1.x > p0.x) ? 1 : ((p1.x < p0.x) ? -1 : 0);
    const int dy = (p1.y > p0.y) ? 1 : ((p1.y < p0.y) ? -1 : 0);
 
    // 查表：行 = dy+1（上/中/下），列 = dx+1（左/中/右）
    constexpr Dir8 DIR8_XY[3][3] = {
        { Dir8::LT, Dir8::TOP,    Dir8::RT },
        { Dir8::LEFT, Dir8::NONE, Dir8::RIGHT },
        { Dir8::LB, Dir8::BOTTOM, Dir8::RB },
    };
    return DIR8_XY[dy + 1][dx + 1];
}

constexpr Dir8 GetDir8R(Dir8 dir)
{
    switch (dir)
    {
    case Dir8::RIGHT:
        return Dir8::LEFT;
    case Dir8::RB:
        return Dir8::LT;
    case Dir8::BOTTOM:
        return Dir8::TOP;
    case Dir8::LB:
        return Dir8::RT;
    case Dir8::LEFT:
        return Dir8::RIGHT;
    case Dir8::LT:
        return Dir8::RB;
    case Dir8::TOP:
        return Dir8::BOTTOM;
    case Dir8::RT:
        return Dir8::LB;
    default:
        break;
    }
    return Dir8::NONE;
}
 
constexpr int Dir8ToMir2(Dir8 dir)
{
    return ((int)dir + 2) % 8;
}

enum class LTRB
{
    LEFT = 0,
    TOP = 1,
    RIGHT = 2,
    BOTTOM = 3
};

enum class Corner
{
    LT = 0,
    RT = 1,
    RB = 2,
    LB = 3,
};

constexpr int MASK_J = 1;
constexpr int MASK_L = 2;
constexpr int MASK_7 = 4;
constexpr int MASK_Γ = 8;
 
template<typename T, typename F>
int GetMask(const std::array<T, 4>& arr, F func)
{
    int ret = 0;
    if (func(arr[0]))
        ret |= MASK_J;
    if (func(arr[1]))
        ret |= MASK_L;
    if (func(arr[2]))
        ret |= MASK_7;
    if (func(arr[3]))
        ret |= MASK_Γ;
    return ret;
}
 
constexpr size_t Mask2Index(int mask)
{
    switch (mask)
    {
    case 0:
        return 6;
    case MASK_J:
        return 3;
    case MASK_L:
        return 4;
    case MASK_J | MASK_L:
        return 11;
    case MASK_7:
        return 8;
    case MASK_J | MASK_7:
        return 7;
    case MASK_L | MASK_7:
        return 14;
    case MASK_J | MASK_L | MASK_7:
        return 12;
    case MASK_Γ:
        return 9;
    case MASK_J | MASK_Γ:
        return 13;
    case MASK_L | MASK_Γ:
        return 5;
    case MASK_J | MASK_L | MASK_Γ:
        return 10;
    case MASK_7 | MASK_Γ:
        return 1;
    case MASK_J | MASK_7 | MASK_Γ:
        return 2;
    case MASK_L | MASK_7 | MASK_Γ:
        return 0;
    case MASK_J | MASK_L | MASK_7 | MASK_Γ:
        return 15;
    default:
        break;
    }
    return -1;
}

template<IsSigned T, std::size_t N>
constexpr Array<T, N> Size2Anchor(const Array<T, N>& size, const Array<Direction, N>& dir)
{
    Array<T, N> ret;
    for (std::size_t i = 0; i < N; ++i)
    {
        ret[i] = (size[i] / static_cast<T>(2)) * ((int)dir[i] + 1);
    }
    return ret;
}

template<IsSigned T, std::size_t N>
constexpr Array<T, N> Size2Anchor(
    const Array<T, N>& size,
    const Array<T, N>& size_self,
    const Array<Direction, N>& dir)
{
    Array<T, N> ret;
    for (std::size_t i = 0; i < N; ++i)
    {
        ret[i] = ((size[i] - size_self[i]) / static_cast<T>(2)) * ((int)dir[i] + 1);
    }
    return ret;
}

template<IsSigned T, std::size_t N>
constexpr Array<T, N> Dir2Offset(const Array<T, N>& size, Dir4 dir)
{
    switch (dir)
    {
    case dl::Align::Dir4::RIGHT:
        return {};
    case dl::Align::Dir4::BOTTOM:
        return {size.h, 0};
    case dl::Align::Dir4::LEFT:
        return { -size.w, -size.h };
    case dl::Align::Dir4::TOP:
        return { size.h, 0 };
    default:
        break;
    }
    return {};
}

inline float Dir2Rotate(Dir4 dir)
{
    switch (dir)
    {
    case Dir4::RIGHT: return 0.0f;
    case Dir4::BOTTOM: return Math::PIF(1, 2);
    case Dir4::LEFT: return Math::PIF(2, 2);
    case Dir4::TOP: return Math::PIF(3, 2);
    }
    return 0.0f;
}
 

Direction2 Anchor2Direction(std::string_view anchor);

Point Anchor2Point(const Size& size, std::string_view anchor);
Position Anchor2Position(const Position& size, std::string_view anchor);
 
//-----------------------获取Rect斜角方位-----------------------------
template<typename T>
constexpr Array<T, 2> GetLT(const Array<T, 4>& rect)
{
    return { rect[(size_t)LTRB::LEFT], rect[(size_t)LTRB::TOP] };
}
template<typename T>
constexpr Array<T, 2> GetRT(const Array<T, 4>& rect)
{
    return { rect[(size_t)LTRB::RIGHT], rect[(size_t)LTRB::TOP] };
}
template<typename T>
constexpr Array<T, 2> GetRB(const Array<T, 4>& rect)
{
    return { rect[(size_t)LTRB::RIGHT], rect[(size_t)LTRB::BOTTOM] };
}
template<typename T>
constexpr Array<T, 2> GetLB(const Array<T, 4>& rect)
{
    return { rect[(size_t)LTRB::LEFT], rect[(size_t)LTRB::BOTTOM] };
}
//-----------------------获取Rect水平垂直方位-----------------------------
template<typename T>
constexpr T& GetLeft(Array<T, 4>& rect)
{
    return rect[(size_t)LTRB::LEFT];
}
template<typename T>
constexpr T& GetTop(Array<T, 4>& rect)
{
    return rect[(size_t)LTRB::TOP];
}
template<typename T>
constexpr T& GetRight(Array<T, 4>& rect)
{
    return rect[(size_t)LTRB::RIGHT];
}
template<typename T>
constexpr T& GetBottom(Array<T, 4>& rect)
{
    return rect[(size_t)LTRB::BOTTOM];
}
 
//-------------------------------隐藏含义获取--------------------------------
template<typename T>
constexpr T GetHeight(const Array<T, 4>& rect)
{
    return rect[3] - rect[1];
}

template<typename T>
constexpr T GetWidth(const Array<T, 4>& rect)
{
    return rect[2] - rect[0];
}

template<typename T>
constexpr Array<T, 2> GetSize(const Array<T, 4>& rect)
{
    return { GetWidth(rect), GetHeight(rect) };
}

template<typename T>
constexpr void Shrink(Array<T, 4>& rect, const T& v)
{
    rect[0] += v;
    rect[1] += v;
    rect[2] -= v;
    rect[3] -= v;
}
template<typename T>
constexpr Array<T, 4> Shrink(const Array<T, 4>& rect, const T& v)
{
    Array<T, 4> ret = rect;
    Shrink(ret, v);
    return ret;
}
 

template<typename T>
constexpr void OffsetRect(Array<T, 4>& rect, const Array<T, 2>& offset)
{
    rect.left += offset.x;
    rect.right += offset.x;
    rect.top += offset.y;
    rect.bottom += offset.y;
}
 
}