dl_vector2.h

浏览该文件的文档.

#pragma once
 
#include <cstddef>
#include <vector>
#include <cassert>
#include <span>
 
#include "dl_type.h"
#include "base/dl_range_accumulate.h"
#include "math/dl_math.h"
 
namespace dl
{
template<typename T, typename Index = unsigned>
class Vector2
{
public:
    using Size = Array<Index, 2>;
    using PointU = Size;
    Vector2() :
        _w{ 0 }
    {}

    Vector2(const Size& size)
    {
        _init(size);
    }

    Vector2(const Size& size, const T* p)
    {
        _init(size);
 
        for (size_t i = 0; i < _data.size(); ++i)
        {
            _data[i] = *(p + i);
        }
    }

    Vector2(const Vector2& b)
    {
        this->operator=(b);
    }

    void Resize(const Size& size)
    {
        Vector2 temp{ *this };
        
        _init(size);
        Fill({});
 
        CopyCross(temp);
    }
 
    Vector2& operator=(const Vector2& b)
    {
        if (this == &b) 
            return *this;
 
        _data = b._data;
        _w = b._w;
        _rebuild_ptr_line((Index)b._ptrLine.size());
        return *this;
    }

    std::span<T> operator[](Index j)
    {
        assert(j < _ptrLine.size());
        return { _ptrLine[j], _w };
    }

    const std::span<T> operator[](Index j) const
    {
        assert(j < _ptrLine.size());
        return { _ptrLine[j], _w };
    }

    /*T& operator[](std::size_t j, std::size_t i)
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        return _ptrLine[j][i];
    }*/
 
    const T& Get(Index j, Index i) const
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        return _ptrLine[j][i];
    }
    const T& Get(const PointU& xy) const
    {
        return Get(xy[1], xy[0]);
    }
    T& GetRef(Index j, Index i)
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        return _ptrLine[j][i];
    }
    T& GetRef(const PointU& xy)
    {
        return GetRef(xy[1], xy[0]);
    }

    T* GetPointer(Index j, Index i)
    {
        if (j >= _ptrLine.size()
            || i >= _w)
            return nullptr;
        return &_ptrLine[j][i];
    }
    T* GetPointer(const PointU& xy)
    {
        return GetPointer(xy[1], xy[0]);
    }
    T* GetPointerOffset(const PointU& xy, const Point& offset)
    {
        Point xy_out = toPoint(xy) + offset;
        if (xy_out[0] < 0 || xy_out[1] < 0)
            return nullptr;
        return GetPointer((Index)xy_out[1], (Index)xy_out[0]);
    }
 
    void Set(Index j, Index i, const T& v)
    {
        assert(j < _ptrLine.size());
        assert(i < _w);
        _ptrLine[j][i] = v;
    }

    void Fill(const T& v)
    {
        for (auto& iter : _data)
            iter = v;
    }
    void Clear()
    {
        _data.clear();
        _w = 0;
        _ptrLine.clear();
    }

    void CopyCross(const Vector2& b)
    {
        Index i_max = (std::min)(_w, b._w);
        Index j_max = (Index)(std::min)(_ptrLine.size(), b._ptrLine.size());
        for(Index j = 0; j < j_max; ++j)
            for (Index i = 0; i < i_max; ++i)
            {
                GetRef(j, i) = b.Get(j, i);
            }
    }

    void PushBack(std::vector<T>& vec)
    {
        assert(vec.size() == _w);
        _data.insert(_data.end(), vec.begin(), vec.end());
        _rebuild_ptr_line((Index)_ptrLine.size() + 1);
    }
 
 
    bool IsEmpty() const { return _data.empty(); }
 
    const std::byte* GetBuffer() const
    {
        return (const std::byte*)_data.data();
    }
 
    T* GetData()
    {
        return _data.data();
    }
    
    const T* GetData() const
    {
        return _data.data();
    }
 
    Index GetWidth() const
    {
        return _w;
    }
 
    Index GetHeight() const
    {
        return (Index)_ptrLine.size();
    }
 
    Size GetSize() const
    {
        return { GetWidth(), GetHeight() };
    }
    
    // 由于标准库 size与 length等价，不使用length命名
    Index GetSizeMul() const
    {
        return GetWidth() * GetHeight();
    }
 
    Index GetSizeByte()
    {
        return (Index)(_data.size() * sizeof(T));
    }
 
    auto begin()
    {
        return _data.begin();
    }
    auto end()
    {
        return _data.end();
    }   
    void reserve(size_t i)
    {
        _data.reserve(i);
    }
    void emplace_back(T&& t)
    {
        _data.emplace_back(t);
    }
    size_t size() const
    {
        return _data.size();
    }
    // 顺时针旋转90度
    static Vector2 RotateRightAngle1(const Vector2& v)
    {
        Vector2 ret;
        ret.Resize({ v.GetHeight(), v.GetWidth() });
 
        for (Index j = 0; j < v.GetHeight(); ++j)
        {
            for (Index i = 0; i < v.GetWidth(); ++i)
            {
                ret[i][v.GetHeight() - j - 1] = v[j][i];
            }
        }
        return ret;
    }
private:
    std::vector<T> _data;
    Index _w;// 宽
    std::vector<T*> _ptrLine; // 行指针
 
    void _init(const Size& size)
    {
        _w = size[0];
        _data.resize(Accumulate::Mul(size));
        _rebuild_ptr_line(size[1]);
    }
    // 重建行指针
    void _rebuild_ptr_line(Index h)
    {
        _ptrLine.resize(h);
        for (Index i = 0; i < _ptrLine.size(); ++i)
            _ptrLine[i] = _data.data() + i * _w;
    }
};
 
 
}