math.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_MATH_H_INCLUDED_
#define PDFSDK_CXX_MATH_H_INCLUDED_
 
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <limits>
#include <optional>
#include <vector>
 
#include <pdfsdk/cxx/exception.h>
#include <pdfsdk/math_types.h>
 
namespace PDF {
 
namespace Math {
 
inline constexpr float EPSILON = 0.0001f;
 
inline constexpr bool FloatLt(float a, float b, float epsilon = EPSILON) {
    return a < b - epsilon;
}
inline constexpr bool FloatGt(float a, float b, float epsilon = EPSILON) {
    return a > b + epsilon;
}
inline constexpr bool FloatEq(float a, float b, float epsilon = EPSILON) {
    return a >= b - epsilon && a <= b + epsilon;
}
inline constexpr bool FloatInRange(float value, float lowerBound, float upperBound, float epsilon = EPSILON) {
    return !FloatLt(value, lowerBound, epsilon) && !FloatGt(value, upperBound, epsilon);
}
 
inline constexpr double PI = 3.14159265358979323846;
 
inline constexpr float RadianToDegree(float radians) {
    return (radians * static_cast<float>(180.0 / PI));
}
inline constexpr double RadianToDegree(double radians) {
    return (radians * (180.0 / PI));
}
 
inline constexpr float DegreeToRadian(float degrees) {
    return (degrees * static_cast<float>(PI / 180.0));
}
inline constexpr double DegreeToRadian(double degrees) {
    return (degrees * (PI / 180.0));
}
}
 
struct PointI : public PDPointI {
    PointI() {
        x = 0;
        y = 0;
    }
 
    PointI(const PointI& that) = default;
    PointI& operator=(const PointI& that) = default;
 
    PointI(int X_, int Y_) {
        x = X_;
        y = Y_;
    }
 
    template<typename XT, typename YT>
    PointI(XT X_, YT Y_) {
        static_assert(std::is_integral_v<XT> && std::is_integral_v<YT>,
                      "Template parameters must be integral types");
        x = static_cast<int>(X_);
        y = static_cast<int>(Y_);
    }
 
    PointI(const PDPointI& that) {
        x = that.x;
        y = that.y;
    }
 
    bool Equals(const PointI& that) const { return x == that.x && y == that.y; }
 
    bool operator==(const PointI& that) const { return Equals(that); }
    bool operator!=(const PointI& that) const { return !Equals(that); }
 
    PointI operator-() const { return PointI(-x, -y); }
 
    void Offset(int dx, int dy) {
        x += dx;
        y += dy;
    }
 
    static PointI MakeOffset(const PointI& point, int dx, int dy) {
        PointI result = point;
        result.Offset(dx, dy);
        return result;
    }
 
    void Mul(int num) {
        x *= num;
        y *= num;
    }
 
    void Div(int num) {
        x /= num;
        y /= num;
    }
 
    PointI& operator+=(const PointI& that) {
        Offset(that.x, that.y);
        return *this;
    }
 
    PointI& operator-=(const PointI& that) {
        Offset(-that.x, -that.y);
        return *this;
    }
 
    PointI& operator*=(int num) {
        Mul(num);
        return *this;
    }
 
    PointI& operator/=(int num) {
        Div(num);
        return *this;
    }
 
    PointI operator+(const PointI& that) { return PointI(x + that.x, y + that.y); }
    PointI operator-(const PointI& that) { return PointI(x - that.x, y - that.y); }
 
    PointI operator*(int num) const { return PointI(x * num, y * num); }
    friend PointI operator*(int num, const PointI& point) { return point * num; }
 
    PointI operator/(int num) const { return PointI(x / num, y / num); }

    static int DistanceManhattan(const PointI& a, const PointI& b) {
        return std::abs(b.x - a.x) + std::abs(b.y - a.y);
    }
};
 
struct PointF : public PDPointF {
    PointF() {
        x = 0.f;
        y = 0.f;
    }
 
    PointF(const PointF& that) = default;
    PointF& operator=(const PointF& that) = default;
 
    PointF(float X_, float Y_) {
        x = X_;
        y = Y_;
    }
 
    PointF(const PDPointF& that) {
        x = that.x;
        y = that.y;
    }
 
    PointF(const PDPointI& pointi) {
        x = static_cast<float>(pointi.x);
        y = static_cast<float>(pointi.y);
    }
 
    PointI Round() const { return PointI(static_cast<int>(std::round(x)), static_cast<int>(std::round(y))); }
    PointI Floor() const { return PointI(static_cast<int>(std::floor(x)), static_cast<int>(std::floor(y))); }
    PointI Ceil() const { return PointI(static_cast<int>(std::ceil(x)), static_cast<int>(std::ceil(y))); }
 
    bool Equals(const PointF& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        return Math::FloatEq(x, that.x, eps) &&
               Math::FloatEq(y, that.y, eps);
    }
 
    bool operator==(const PointF& that) const { return Equals(that); }
    bool operator!=(const PointF& that) const { return !Equals(that); }
 
    PointF operator-() const { return PointF{-x, -y}; }
 
    void Offset(float dx, float dy) {
        x += dx;
        y += dy;
    }
 
    static PointF MakeOffset(const PointF& point, float dx, float dy) {
        PointF result = point;
        result.Offset(dx, dy);
        return result;
    }
 
    void Mul(float num) {
        x *= num;
        y *= num;
    }
 
    void Div(float num) {
        x /= num;
        y /= num;
    }
 
    PointF& operator+=(const PointF& that) {
        Offset(that.x, that.y);
        return *this;
    }
 
    PointF& operator-=(const PointF& that) {
        Offset(-that.x, -that.y);
        return *this;
    }
 
    PointF& operator*=(float num) {
        Mul(num);
        return *this;
    }
 
    PointF& operator/=(float num) {
        Div(num);
        return *this;
    }
 
    PointF operator+(const PointF& that) const { return PointF(x + that.x, y + that.y); }
    PointF operator-(const PointF& that) const { return PointF(x - that.x, y - that.y); }
 
    PointF operator*(float num) const { return PointF(x * num, y * num); }
    friend PointF operator*(float num, const PointF& point) { return point * num; }
 
    PointF operator/(float num) const { return PointF(x / num, y / num); }

    static float DistanceSquared(const PointF& a, const PointF& b) {
        return (b - a).VectorMagnitudeSquared();
    }

    static float Distance(const PointF& a, const PointF& b) {
        return (b - a).VectorMagnitude();
    }
    
    float DistanceToEdge(const PointF& a, const PointF& b) const {
        PointF p = *this;
 
        // сompute squared length of segment AB
        float d = DistanceSquared(a, b);
 
        if (Math::FloatEq(d, 0.f))
            // segment is degenerate (A == B), return distance to point A
            return Distance(p, a);
 
        // compute projection factor t of point P onto line AB
        float t = VectorDotProduct(p - a, b - a) / d;
 
        if (Math::FloatLt(t, 0.f))
            // projection falls before point A, return distance to A
            return Distance(p, a);
 
        if (Math::FloatGt(t, 1.f))
            // projection falls after point B, return distance to B
            return Distance(p, b);
 
        // projection falls on segment AB, return distance to projected point
        return Distance(p, a + t * (b - a));
    }

    static float DistanceManhattan(const PointF& a, const PointF& b) {
        return std::abs(b.x - a.x) + std::abs(b.y - a.y);
    }

    float TestSide(const PointF& a, const PointF& b) const { return VectorCrossProduct(b - a, *this - a); }
    
    static PointF AtCenter(const PointF& a, const PointF& b) { return (a + b) / 2.0f; }

    float VectorMagnitudeSquared() const { return x * x + y * y; }

    float VectorMagnitude() const { return std::sqrt(VectorMagnitudeSquared()); }

    static float VectorDotProduct(const PointF& a, const PointF& b) { return a.x * b.x + a.y * b.y; }

    static float VectorCrossProduct(const PointF& a, const PointF& b) { return a.x * b.y - b.x * a.y; }

    static float VectorAngleBetween(const PointF& a, const PointF& b) {
        return std::atan2(b.y, b.x) - std::atan2(a.y, a.x);
    }

    PointF& VectorNormalize() {
        float mag = VectorMagnitude();
        if (!Math::FloatEq(mag, 0.f))
            Div(mag);
        return *this;
    }

    static PointF VectorNormalTo(const PointF& v) { return PointF(-v.y, v.x); }
};
 
namespace Math {

inline bool EdgeIntersectsEdge(const PointF& a0, const PointF& a1, const PointF& b0, const PointF& b1) {
    auto va = a1 - a0;
    auto vb = b1 - b0;
    float d = PointF::VectorCrossProduct(va, vb);
    if (Math::FloatEq(d, 0.f))
        return false;
 
    auto vc = a0 - b0;
    float r = PointF::VectorCrossProduct(vb, vc) / d;
    if (Math::FloatLt(r, 0.f) || Math::FloatGt(r, 1.f))
        return false;
    float s = PointF::VectorCrossProduct(va, vc) / d;
    if (Math::FloatLt(s, 0.f) || Math::FloatGt(s, 1.f))
        return false;
 
    return true;
}
}
 
struct SizeI : public PDSizeI {
    SizeI() {
        width = 0;
        height = 0;
    }
 
    SizeI(const SizeI& that) = default;
    SizeI& operator=(const SizeI& that) = default;
 
    SizeI(int width_, int height_) {
        width = width_;
        height = height_;
    }
 
    template<typename WT, typename HT>
    SizeI(WT width_, HT height_) {
        static_assert(std::is_integral_v<WT> && std::is_integral_v<HT>,
                      "Template parameters must be integral types");
        width = static_cast<int>(width_);
        height = static_cast<int>(height_);
    }
 
    SizeI(const PDSizeI& sz) {
        width = sz.width;
        height = sz.height;
    }
 
    bool Equals(const SizeI& that) const {
        if (this == &that)
            return true;
        return width == that.width && height == that.height;
    }
 
    bool operator==(const SizeI& that) const { return Equals(that); }
    bool operator!=(const SizeI& that) const { return !Equals(that); }
 
    int GetArea() const { return width * height; }
    bool IsAreaEmpty() const { return width == 0 || height == 0; }
};
 
struct SizeF : public PDSizeF {
    SizeF() {
        width = 0.f;
        height = 0.f;
    }
 
    SizeF(const SizeF& that) = default;
    SizeF& operator=(const SizeF& that) = default;
 
    SizeF(float width_, float height_) {
        width = width_;
        height = height_;
    }
 
    SizeF(const PDSizeF& that) {
        width = that.width;
        height = that.height;
    }
 
    SizeF(const PDSizeI& sizei) {
        width = static_cast<float>(sizei.width);
        height = static_cast<float>(sizei.height);
    }
 
    SizeI Round() const { return SizeI(static_cast<int>(std::round(width)), static_cast<int>(std::round(height))); }
    SizeI Floor() const { return SizeI(static_cast<int>(std::floor(width)), static_cast<int>(std::floor(height))); }
    SizeI Ceil() const { return SizeI(static_cast<int>(std::ceil(width)), static_cast<int>(std::ceil(height))); }
 
    bool Equals(const SizeF& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        return Math::FloatEq(width, that.width, eps) &&
               Math::FloatEq(height, that.height, eps);
    }
 
    bool operator==(const SizeF& that) const { return Equals(that); }
    bool operator!=(const SizeF& that) const { return !Equals(that); }
 
    float GetArea() const { return width * height; }
    bool IsAreaEmpty() const { return width == 0.f || height == 0.f; }
};
 
struct RectI : public PDRectI {
    RectI() {
        left = 0;
        top = 0;
        right = 0;
        bottom = 0;
    }
 
    RectI(const RectI& that) = default;
    RectI& operator=(const RectI& that) = default;
 
    RectI(int left_, int top_, int right_, int bottom_) {
        left = left_;
        top = top_;
        right = right_;
        bottom = bottom_;
    }
 
    explicit RectI(const SizeI& size) {
        left = 0;
        top = 0;
        right = size.width;
        bottom = size.height;
    }
 
    RectI(const PointI& origin, const SizeI& size) {
        left = origin.x;
        top = origin.y;
        right = origin.x + size.width;
        bottom = origin.y + size.height;
    }
 
    RectI(const PointI& leftTop, const PointI& rightBottom) {
        left = leftTop.x;
        top = leftTop.y;
        right = rightBottom.x;
        bottom = rightBottom.y;
    }
 
    RectI(const PDRectI& that) {
        left = that.left;
        top = that.top;
        right = that.right;
        bottom = that.bottom;
    }
 
    void SortForPageSpace() {
        if (left > right)
            std::swap(left, right);
        if (bottom > top)
            std::swap(top, bottom);
    }
    static RectI MakeSortedForPageSpace(const RectI& rect) {
        RectI result = rect;
        result.SortForPageSpace();
        return result;
    }
 
    void SortForDeviceSpace() {
        if (left > right)
            std::swap(left, right);
        if (top > bottom)
            std::swap(top, bottom);
    }
    static RectI MakeSortedForDeviceSpace(const RectI& rect) {
        RectI result = rect;
        result.SortForDeviceSpace();
        return result;
    }
 
#ifndef SWIG
    int& MinX() { return (left <= right ? left : right); }
    int& MaxX() { return (left > right ? left : right); }
    int& MinY() { return (top <= bottom ? top : bottom); }
    int& MaxY() { return (top > bottom ? top : bottom); }
#endif
 
    int MinX() const { return (std::min)(left, right); }
    int MaxX() const { return (std::max)(left, right); }
    int MinY() const { return (std::min)(top, bottom); }
    int MaxY() const { return (std::max)(top, bottom); }
 
    bool Equals(const RectI& that) const {
        if (this == &that)
            return true;
        return MinX() == that.MinX() &&
               MaxX() == that.MaxX() &&
               MinY() == that.MinY() &&
               MaxY() == that.MaxY();
    }
 
    bool operator==(const RectI& that) const { return Equals(that); }
    bool operator!=(const RectI& that) const { return !Equals(that); }
 
    int GetWidth() const { return std::abs(right - left); }
    int GetHeight() const { return std::abs(top - bottom); }
 
    int GetArea() const { return GetWidth() * GetHeight(); }
    bool IsAreaEmpty() const { return left == right || top == bottom; }
 
    PointI GetOrigin() const { return PointI(MinX(), MinY()); }
    SizeI GetSize() const { return SizeI(GetWidth(), GetHeight()); }
 
    PointI GetLeftTop() const { return PointI(left, top); }
    PointI GetLeftCenter() const { return PointI(left, MinY() + GetHeight() / 2); }
    PointI GetLeftBottom() const { return PointI(left, bottom); }
 
    PointI GetCenterTop() const { return PointI(MinX() + GetWidth() / 2, top); }
    PointI GetCenter() const { return PointI(MinX() + GetWidth() / 2, MinY() + GetHeight() / 2); }
    PointI GetCenterBottom() const { return PointI(MinX() + GetWidth() / 2, bottom); }
 
    PointI GetRightTop() const { return PointI(right, top); }
    PointI GetRightCenter() const { return PointI(right, MinY() + GetHeight() / 2); }
    PointI GetRightBottom() const { return PointI(right, bottom); }
 
    void Offset(int dx, int dy) {
        left += dx;
        top += dy;
        right += dx;
        bottom += dy;
    }
    void Offset(const PointI& delta) { Offset(delta.x, delta.y); }
    static RectI MakeOffset(const RectI& rect, int dx, int dy) {
        RectI result = rect;
        result.Offset(dx, dy);
        return result;
    }
    static RectI MakeOffset(const RectI& rect, const PointI& delta) { return MakeOffset(rect, delta.x, delta.y); }
 
    RectI& operator+=(const PointI& point) {
        Offset(point);
        return *this;
    }
    RectI& operator-=(const PointI& point) {
        Offset(-point);
        return *this;
    }
    RectI operator+(const PointI& point) const { return MakeOffset(*this, point); }
    RectI operator-(const PointI& point) const { return MakeOffset(*this, -point); }
 
    void Inflate(int dx, int dy) {
        auto& minX = MinX();
        auto& minY = MinY();
        auto& maxX = MaxX();
        auto& maxY = MaxY();
        minX -= dx;
        maxX += dx;
        minY -= dy;
        maxY += dy;
    }
    void Inflate(int delta) { return Inflate(delta, delta); }
    static RectI MakeInflated(const RectI& rect, int dx, int dy) {
        RectI result = rect;
        result.Inflate(dx, dy);
        return result;
    }
    static RectI MakeInflated(const RectI& rect, int delta) { return MakeInflated(rect, delta, delta); }
 
    void Extend(const PointI& point) {
        MinX() = (std::min)(MinX(), point.x);
        MinY() = (std::min)(MinY(), point.y);
        MaxX() = (std::max)(MaxX(), point.x);
        MaxY() = (std::max)(MaxY(), point.y);
    }
    static RectI MakeExtended(const RectI& rect, const PointI& point) {
        RectI result = rect;
        result.Extend(point);
        return result;
    }
 
    bool Contains(const PointI& point) const {
        return point.x >= MinX() && point.x < MaxX() && point.y >= MinY() && point.y < MaxY();
    }
    bool Contains(const RectI& rect) const {
        return MinX() <= rect.MinX() && MaxX() >= rect.MaxX() && MinY() <= rect.MinY() && MaxY() >= rect.MaxY();
    }
 
    bool HasIntersection(const RectI& rect) const {
        return MinX() < rect.MaxX() && MinY() < rect.MaxY() && MaxX() > rect.MinX() && MaxY() > rect.MinY();
    }
    static RectI MakeIntersection(const RectI& a, const RectI& b) {
        if (!a.HasIntersection(b))
            return RectI();
 
        RectI i = a;
        i.MinX() = (std::max)(a.MinX(), b.MinX());
        i.MinY() = (std::max)(a.MinY(), b.MinY());
        i.MaxX() = (std::min)(a.MaxX(), b.MaxX());
        i.MaxY() = (std::min)(a.MaxY(), b.MaxY());
        return i;
    }
 
    static RectI MakeUnion(const RectI& a, const RectI& b) {
        RectI u = a;
        u.MinX() = (std::min)(a.MinX(), b.MinX());
        u.MinY() = (std::min)(a.MinY(), b.MinY());
        u.MaxX() = (std::max)(a.MaxX(), b.MaxX());
        u.MaxY() = (std::max)(a.MaxY(), b.MaxY());
        return u;
    }
    static RectI MakeUnionIgnoringEmpty(const RectI& a, const RectI& b) {
        if (a.IsAreaEmpty())
            return b;
        if (b.IsAreaEmpty())
            return a;
        return MakeUnion(a, b);
    }
};
 
struct RectF : public PDRectF {
    RectF() {
        left = 0.f;
        top = 0.f;
        right = 0.f;
        bottom = 0.f;
    }
 
    RectF(const RectF& that) = default;
    RectF& operator=(const RectF& that) = default;
 
    RectF(float left_, float top_, float right_, float bottom_) {
        left = left_;
        top = top_;
        right = right_;
        bottom = bottom_;
    }
 
    RectF(const PDRectF& rect) {
        left = rect.left;
        top = rect.top;
        right = rect.right;
        bottom = rect.bottom;
    }
 
    explicit RectF(const SizeF& size) {
        left = 0.f;
        top = size.height;
        right = size.width;
        bottom = 0.f;
    }
 
    RectF(const PointF& origin, const SizeF& size) {
        left = origin.x;
        top = origin.y + size.height;
        right = origin.x + size.width;
        bottom = origin.y;
    }
 
    RectF(const PointF& leftTop, const PointF& rightBottom) {
        left = leftTop.x;
        top = leftTop.y;
        right = rightBottom.x;
        bottom = rightBottom.y;
    }
 
    RectF(const RectI& recti) {
        left = static_cast<float>(recti.left);
        top = static_cast<float>(recti.top);
        right = static_cast<float>(recti.right);
        bottom = static_cast<float>(recti.bottom);
    }
 
#ifndef SWIG
    template<class PointsIter>
    static RectF EnclosingPoints(const PointsIter& pointsBegin, const PointsIter& pointsEnd) {
        RectF rect;
        auto it = pointsBegin;
        if (it != pointsEnd) {
            rect = RectF(*it, *it);
            while (++it != pointsEnd)
                rect.Extend(*it);
        }
        return rect;
    }
 
    template<class PointsContainer>
    static RectF EnclosingPoints(const PointsContainer& points) {
        return EnclosingPoints(std::begin(points), std::end(points));
    }
 
    static RectF EnclosingPoints(const std::initializer_list<PointF>& points) {
        return EnclosingPoints(std::begin(points), std::end(points));
    }
#endif
 
    RectI Round() const {
        return RectI(static_cast<int>(std::round(MinX())),
                     static_cast<int>(std::round(MinY())),
                     static_cast<int>(std::round(MaxX())),
                     static_cast<int>(std::round(MaxY())));
    }
    RectI Floor() const {
        return RectI(static_cast<int>(std::ceil(MinX())),
                     static_cast<int>(std::ceil(MinY())),
                     static_cast<int>(std::floor(MaxX())),
                     static_cast<int>(std::floor(MaxY())));
    }
    RectI Ceil() const {
        return RectI(static_cast<int>(std::floor(MinX())),
                     static_cast<int>(std::floor(MinY())),
                     static_cast<int>(std::ceil(MaxX())),
                     static_cast<int>(std::ceil(MaxY())));
    }
 
    void SortForPageSpace() {
        if (left > right)
            std::swap(left, right);
        if (bottom > top)
            std::swap(top, bottom);
    }
    static RectF MakeSortedForPageSpace(const RectF& rect) {
        RectF result = rect;
        result.SortForPageSpace();
        return result;
    }
 
    void SortForDeviceSpace() {
        if (left > right)
            std::swap(left, right);
        if (top > bottom)
            std::swap(top, bottom);
    }
    static RectF MakeSortedForDeviceSpace(const RectF& rect) {
        RectF result = rect;
        result.SortForDeviceSpace();
        return result;
    }
 
#ifndef SWIG
    float& MinX() { return (left <= right ? left : right); }
    float& MaxX() { return (left > right ? left : right); }
    float& MinY() { return (top <= bottom ? top : bottom); }
    float& MaxY() { return (top > bottom ? top : bottom); }
#endif
 
    float MinX() const { return (std::min)(left, right); }
    float MaxX() const { return (std::max)(left, right); }
    float MinY() const { return (std::min)(top, bottom); }
    float MaxY() const { return (std::max)(top, bottom); }
 
    bool Equals(const RectF& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        return Math::FloatEq(MinX(), that.MinX(), eps) &&
               Math::FloatEq(MaxX(), that.MaxX(), eps) &&
               Math::FloatEq(MinY(), that.MinY(), eps) &&
               Math::FloatEq(MaxY(), that.MaxY(), eps);
    }
 
    bool operator==(const RectF& that) const { return Equals(that); }
    bool operator!=(const RectF& that) const { return !Equals(that); }
 
    float GetWidth() const { return std::abs(right - left); }
    float GetHeight() const { return std::abs(top - bottom); }
 
    float GetArea() const { return GetWidth() * GetHeight(); }
    bool IsAreaEmpty() const { return Math::FloatEq(left, right) || Math::FloatEq(top, bottom); }
 
    PointF GetOrigin() const { return PointF(MinX(), MinY()); }
    SizeF GetSize() const { return SizeF(GetWidth(), GetHeight()); }
 
    PointF GetLeftTop() const { return PointF(left, top); }
    PointF GetLeftCenter() const { return PointF::AtCenter(GetLeftBottom(), GetLeftTop()); }
    PointF GetLeftBottom() const { return PointF(left, bottom); }
 
    PointF GetCenterTop() const { return PointF::AtCenter(GetLeftTop(), GetRightTop()); }
    PointF GetCenter() const { return PointF(MinX() + GetWidth() / 2.f, MinY() + GetHeight() / 2.f); }
    PointF GetCenterBottom() const { return PointF::AtCenter(GetLeftBottom(), GetRightBottom()); }
 
    PointF GetRightTop() const { return PointF(right, top); }
    PointF GetRightCenter() const { return PointF::AtCenter(GetRightBottom(), GetRightTop()); }
    PointF GetRightBottom() const { return PointF(right, bottom); }
 
    void Offset(float dx, float dy) {
        left += dx;
        top += dy;
        right += dx;
        bottom += dy;
    }
    void Offset(const PointF& delta) { Offset(delta.x, delta.y); }
    static RectF MakeOffset(const RectF& rect, float dx, float dy) {
        RectF result = rect;
        result.Offset(dx, dy);
        return result;
    }
    static RectF MakeOffset(const RectF& rect, const PointF& delta) { return MakeOffset(rect, delta.x, delta.y); }
 
    void MoveTo(float x, float y) { Offset(x - MinX(), y - MinY()); }
    void MoveTo(const PointF& point) { MoveTo(point.x, point.y); }
    static RectF MakeMoved(const RectF& rect, float x, float y) {
        RectF result = rect;
        result.MoveTo(x, y);
        return result;
    }
    static RectF MakeMoved(const RectF& rect, const PointF& point) { return MakeMoved(rect, point.x, point.y); }
 
    RectF& operator+=(const PointF& point) {
        Offset(point);
        return *this;
    }
    RectF& operator-=(const PointF& point) {
        Offset(-point);
        return *this;
    }
    RectF operator+(const PointF& point) const { return (RectF(*this) += point); }
    RectF operator-(const PointF& point) const { return (RectF(*this) -= point); }
 
    void Inflate(float dx, float dy) {
        auto& minX = MinX();
        auto& minY = MinY();
        auto& maxX = MaxX();
        auto& maxY = MaxY();
        minX -= dx;
        maxX += dx;
        minY -= dy;
        maxY += dy;
    }
    void Inflate(float delta) { Inflate(delta, delta); }
    static RectF MakeInflated(const RectF& rect, float dx, float dy) {
        RectF result = rect;
        result.Inflate(dx, dy);
        return result;
    }
    static RectF MakeInflated(const RectF& rect, float delta) { return MakeInflated(rect, delta, delta); }
 
    void Extend(const PointF& point) {
        float& minX = MinX();
        float& minY = MinY();
        float& maxX = MaxX();
        float& maxY = MaxY();
        minX = (std::min)(minX, point.x);
        minY = (std::min)(minY, point.y);
        maxX = (std::max)(maxX, point.x);
        maxY = (std::max)(maxY, point.y);
    }
    static RectF MakeExtended(const RectF& rect, const PointF& point) {
        RectF result = rect;
        result.Extend(point);
        return result;
    }
 
    bool Contains(const PointF& point) const {
        return point.x >= MinX() && point.x <= MaxX() && point.y >= MinY() && point.y <= MaxY();
    }
    bool Contains(const RectF& rect) const {
        return MinX() <= rect.MinX() && MaxX() >= rect.MaxX() && MinY() <= rect.MinY() && MaxY() >= rect.MaxY();
    }
 
    bool HasIntersectionWithEdge(const PointF& a, const PointF& b) const {
        return (Contains(a) ||
                Contains(b) ||
                Math::EdgeIntersectsEdge(GetLeftTop(), GetRightTop(), a, b) ||
                Math::EdgeIntersectsEdge(GetRightTop(), GetRightBottom(), a, b) ||
                Math::EdgeIntersectsEdge(GetRightBottom(), GetLeftBottom(), a, b) ||
                Math::EdgeIntersectsEdge(GetLeftBottom(), GetLeftTop(), a, b));
    }
    bool HasIntersection(const RectF& rect) const {
        return MinX() < rect.MaxX() && MinY() < rect.MaxY() && MaxX() > rect.MinX() && MaxY() > rect.MinY();
    }
 
    static RectF MakeIntersection(const RectF& a, const RectF& b) {
        if (!a.HasIntersection(b))
            return RectF();
 
        RectF i = a;
        i.MinX() = (std::max)(a.MinX(), b.MinX());
        i.MinY() = (std::max)(a.MinY(), b.MinY());
        i.MaxX() = (std::min)(a.MaxX(), b.MaxX());
        i.MaxY() = (std::min)(a.MaxY(), b.MaxY());
        return i;
    }
 
    static RectF MakeUnion(const RectF& a, const RectF& b) {
        RectF u = a;
        u.MinX() = (std::min)(a.MinX(), b.MinX());
        u.MinY() = (std::min)(a.MinY(), b.MinY());
        u.MaxX() = (std::max)(a.MaxX(), b.MaxX());
        u.MaxY() = (std::max)(a.MaxY(), b.MaxY());
        return u;
    }
 
    static RectF MakeUnionIgnoringEmpty(const RectF& a, const RectF& b) {
        if (a.IsAreaEmpty())
            return b;
        if (b.IsAreaEmpty())
            return a;
        return MakeUnion(a, b);
    }
};
 
struct Quad : public PDQuad {
    Quad() {
        topleft = PointF();
        topright = PointF();
        botleft = PointF();
        botright = PointF();
    }
 
    Quad(const Quad& that) = default;
    Quad& operator=(const Quad& that) = default;
 
    Quad(const PDQuad& that) {
        topleft = that.topleft;
        topright = that.topright;
        botleft = that.botleft;
        botright = that.botright;
    }
 
    Quad(const PointF& leftTop_, const PointF& rightTop_, const PointF& leftBottom_, const PointF& rightBottom_) {
        topleft = leftTop_;
        topright = rightTop_;
        botleft = leftBottom_;
        botright = rightBottom_;
    }
 
    explicit Quad(const PDRectF& rect) {
        topleft = PointF(rect.left, rect.top);
        topright = PointF(rect.right, rect.top);
        botleft = PointF(rect.left, rect.bottom);
        botright = PointF(rect.right, rect.bottom);
    }
 
    explicit Quad(const RectF& rect) {
        topleft = PointF(rect.left, rect.top);
        topright = PointF(rect.right, rect.top);
        botleft = PointF(rect.left, rect.bottom);
        botright = PointF(rect.right, rect.bottom);
    }
 
    PointF GetLeftTop() const { return topleft; }
    PointF GetLeftCenter() const { return PointF::AtCenter(GetLeftBottom(), GetLeftTop()); }
    PointF GetLeftBottom() const { return botleft; }
 
    PointF GetCenterTop() const { return PointF::AtCenter(GetLeftTop(), GetRightTop()); }
    PointF GetCenter() const { return PointF::AtCenter(PointF::AtCenter(topleft, botright), PointF::AtCenter(topright, botleft)); }
    PointF GetCenterBottom() const { return PointF::AtCenter(GetLeftBottom(), GetRightBottom()); }
 
    PointF GetRightTop() const { return topright; }
    PointF GetRightBottom() const { return botright; }
    PointF GetRightCenter() const { return PointF::AtCenter(GetRightBottom(), GetRightTop()); }
 
    RectF GetBound() const {
        auto [minx, maxx] = std::minmax({topleft.x, topright.x, botleft.x, botright.x});
        auto [miny, maxy] = std::minmax({topleft.y, topright.y, botleft.y, botright.y});
        return RectF(minx, maxy, maxx, miny);
    }
 
    float GetRotationAngle() const { return std::atan2(topright.y - topleft.y, topright.x - topleft.x); }
 
    bool IsRectangle() const {
        return (std::min)(topleft.x, botright.x) == (std::min)(botleft.x, topright.x) &&
               (std::max)(topleft.x, botright.x) == (std::max)(botleft.x, topright.x) &&
               (std::min)(topleft.y, botright.y) == (std::min)(botleft.y, topright.y) &&
               (std::max)(topleft.y, botright.y) == (std::max)(botleft.y, topright.y);
    }
 
    bool Equals(const Quad& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        return GetLeftTop().Equals(that.GetLeftTop(), eps) &&
               GetRightTop().Equals(that.GetRightTop(), eps) &&
               GetLeftBottom().Equals(that.GetLeftBottom(), eps) &&
               GetRightBottom().Equals(that.GetRightBottom(), eps);
    }
 
    bool operator==(const Quad& that) const { return Equals(that); }
    bool operator!=(const Quad& that) const { return !Equals(that); }
 
    void Offset(float dx, float dy) {
        topleft.x += dx;
        topleft.y += dy;
        topright.x += dx;
        topright.y += dy;
        botleft.x += dx;
        botleft.y += dy;
        botright.x += dx;
        botright.y += dy;
    }
    void Offset(const PointF& point) { Offset(point.x, point.y); }
 
    static Quad MakeOffset(const Quad& quad, float dx, float dy) {
        Quad result = quad;
        result.Offset(dx, dy);
        return result;
    }
    static Quad MakeOffset(const Quad& quad, const PointF& delta) { return MakeOffset(quad, delta.x, delta.y); }
 
    Quad& operator+=(const PointF& point) {
        Offset(point);
        return *this;
    }
    Quad& operator-=(const PointF& point) {
        Offset(-point);
        return *this;
    }
 
    Quad operator+(const PointF& point) const { return (Quad(*this) += point); }
    Quad operator-(const PointF& point) const { return (Quad(*this) -= point); }
 
    bool Contains(const PointF& point) const {
        RectF bound = GetBound();
        if (!bound.Contains(point))
            return false;
 
        if (point == topleft || point == topright || point == botleft || point == botright)
            return true;
 
        if (Math::FloatEq(0.f, point.DistanceToEdge(topleft, topright)) ||
            Math::FloatEq(0.f, point.DistanceToEdge(topright, botright)) ||
            Math::FloatEq(0.f, point.DistanceToEdge(botright, botleft)) ||
            Math::FloatEq(0.f, point.DistanceToEdge(botleft, topleft)))
            return true;
 
        int winding = 0;
        winding += (point.TestSide(topleft, topright) > 0) ? 1 : -1;
        winding += (point.TestSide(topright, botright) > 0) ? 1 : -1;
        winding += (point.TestSide(botright, botleft) > 0) ? 1 : -1;
        winding += (point.TestSide(botleft, topleft) > 0) ? 1 : -1;
        return winding != 0;
    }
 
    bool Contains(const Quad& that) const {
        return Contains(that.GetLeftTop()) &&
               Contains(that.GetRightTop()) &&
               Contains(that.GetLeftBottom()) &&
               Contains(that.GetRightBottom());
    }
 
    bool HasIntersectionWithEdge(const PointF& a, const PointF& b) const {
        return (Contains(a) ||
                Contains(b) ||
                Math::EdgeIntersectsEdge(GetLeftTop(), GetRightTop(), a, b) ||
                Math::EdgeIntersectsEdge(GetRightTop(), GetRightBottom(), a, b) ||
                Math::EdgeIntersectsEdge(GetRightBottom(), GetLeftBottom(), a, b) ||
                Math::EdgeIntersectsEdge(GetLeftBottom(), GetLeftTop(), a, b));
    }
 
    bool HasIntersection(const RectF& rect) const {
        return HasIntersection(Quad{rect});
    }
 
    bool HasIntersection(const Quad& quad) const {
        return (Contains(quad.GetLeftTop()) ||
                Contains(quad.GetRightTop()) ||
                Contains(quad.GetRightBottom()) ||
                Contains(quad.GetLeftBottom()) ||
                quad.Contains(GetLeftTop()) ||
                quad.Contains(GetRightTop()) ||
                quad.Contains(GetRightBottom()) ||
                quad.Contains(GetLeftBottom()) ||
                HasIntersectionWithEdge(quad.GetLeftTop(), quad.GetRightTop()) ||
                HasIntersectionWithEdge(quad.GetRightTop(), quad.GetRightBottom()) ||
                HasIntersectionWithEdge(quad.GetRightBottom(), quad.GetLeftBottom()) ||
                HasIntersectionWithEdge(quad.GetLeftBottom(), quad.GetLeftTop()));
    }
};
 
struct QuadPoints {
    QuadPoints() = default;
 
    explicit QuadPoints(std::vector<Quad> Quads_)
            : quads(std::move(Quads_)) {
    }
 
    RectF GetBound() const {
        RectF rect;
        if (!quads.empty()) {
            rect = quads[0].GetBound();
            for (const auto& quad : quads)
                rect = RectF::MakeUnion(rect, quad.GetBound());
        }
        return rect;
    }
 
    bool Equals(const QuadPoints& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        if (quads.size() != that.quads.size())
            return false;
        for (size_t i = 0; i < quads.size(); ++i) {
            if (!(quads[i].Equals(that.quads[i], eps)))
                return false;
        }
        return true;
    }
 
    bool operator==(const QuadPoints& that) const { return Equals(that); }
    bool operator!=(const QuadPoints& that) const { return !Equals(that); }
 
    QuadPoints Optimize() const {
        if (quads.empty())
            return QuadPoints();
 
        std::vector<Quad> merged;
 
        static constexpr auto areLinesCollinear = [](const PointF& p0, const PointF& p1, const PointF& p2) {
            return Math::FloatEq(PointF::VectorCrossProduct(p1 - p0, p2 - p0), 0.f);
        };
 
        Quad quad;
        bool initialized = false;
        for (size_t i = 0; i <= quads.size(); ++i) {
            if (i == quads.size()) {
                merged.emplace_back(quad);
                break;
            }
 
            auto& newQuad = quads[i];
            if (!initialized) {
                quad = newQuad;
                initialized = true;
            } else {
                if (areLinesCollinear(quad.GetLeftBottom(), quad.GetRightBottom(), newQuad.GetLeftBottom()) &&
                    areLinesCollinear(quad.GetLeftTop(), quad.GetRightTop(), newQuad.GetLeftTop()) &&
                    quad.HasIntersection(newQuad)) {
                    quad.topright = newQuad.GetRightTop();
                    quad.botright = newQuad.GetRightBottom();
                } else {
                    merged.emplace_back(quad);
                    quad = newQuad;
                }
            }
        }
 
        return QuadPoints(std::move(merged));
    }
 
    std::vector<Quad> quads;
};

struct Matrix : public PDMatrix {
    Matrix() {
        a = 1.f;
        b = 0.f;
        c = 0.f;
        d = 1.f;
        e = 0.f;
        f = 0.f;
    }
 
    Matrix(const Matrix& that) = default;
    Matrix& operator=(const Matrix& that) = default;
 
    Matrix(float a_, float b_, float c_, float d_, float e_, float f_) {
        a = a_;
        b = b_;
        c = c_;
        d = d_;
        e = e_;
        f = f_;
    }
 
    Matrix(const PDMatrix& that) {
        a = that.a;
        b = that.b;
        c = that.c;
        d = that.d;
        e = that.e;
        f = that.f;
    }
 
    bool Equals(const Matrix& that, const float eps = Math::EPSILON) const {
        if (this == &that)
            return true;
        return Math::FloatEq(a, that.a, eps) &&
               Math::FloatEq(b, that.b, eps) &&
               Math::FloatEq(c, that.c, eps) &&
               Math::FloatEq(d, that.d, eps) &&
               Math::FloatEq(e, that.e, eps) &&
               Math::FloatEq(f, that.f, eps);
    }
 
    bool operator==(const Matrix& that) const { return Equals(that); }
    bool operator!=(const Matrix& that) const { return !Equals(that); }
 
    bool IsIdentity() const { return *this == Matrix{}; }
 
    static Matrix Concat(const Matrix& lhs, const Matrix& rhs) {
        return Matrix(lhs.a * rhs.a + lhs.b * rhs.c,
                      lhs.a * rhs.b + lhs.b * rhs.d,
                      lhs.c * rhs.a + lhs.d * rhs.c,
                      lhs.c * rhs.b + lhs.d * rhs.d,
                      lhs.e * rhs.a + lhs.f * rhs.c + rhs.e,
                      lhs.e * rhs.b + lhs.f * rhs.d + rhs.f);
    }
 
    Matrix operator*(const Matrix& that) const { return Concat(*this, that); }
    Matrix& operator*=(const Matrix& that) { return (*this = *this * that); }
 
    PointF MapPoint(const PointF& point) const {
        return PointF(a * point.x + c * point.y + e, b * point.x + d * point.y + f);
    }
 
    SizeF MapSize(const SizeF& size) const {
        return SizeF(a * size.width + c * size.height, b * size.width + d * size.height);
    }
 
    RectF MapRect(const RectF& rect) const {
        return MapQuad(Quad{rect}).GetBound();
    }
 
    Quad MapQuad(const Quad& quad) const {
        return Quad(MapPoint(quad.GetLeftTop()),
                    MapPoint(quad.GetRightTop()),
                    MapPoint(quad.GetLeftBottom()),
                    MapPoint(quad.GetRightBottom()));
    }
 
    float GetScalingX() const {
        return std::sqrt(a * a + c * c);
    }
 
    float GetScalingY() const {
        return std::sqrt(b * b + d * d);
    }
 
    bool HasRotation() const {
        return !Math::FloatEq(b, 0.f) || !Math::FloatEq(c, 0.f);
    }
 
    float GetRotation() const {
        return std::atan2(b, a);
    }
 
    float GetRotationDegrees() const {
        return Math::RadianToDegree(GetRotation());
    }
 
    double Determinant() const { return static_cast<double>(a) * d - static_cast<double>(b) * c; }
 
    static Matrix Scaling(float value) { return Scaling(value, value); }
    static Matrix Scaling(float x, float y) { return Matrix(x, 0.f, 0.f, y, 0.f, 0.f); }
    static Matrix Scaling(const SizeF& scaling) { return Scaling(scaling.width, scaling.height); }
    static Matrix Scaling(float value, const PointF& origin) { return Scaling(value, value, origin); }
    static Matrix Scaling(float x, float y, const PointF& origin) { return Matrix(x, 0.f, 0.f, y, (1.f - x) * origin.x, (1.f - y) * origin.y); }
    static Matrix Scaling(const SizeF& scaling, const PointF& origin) { return Scaling(scaling.width, scaling.height, origin); }
 
    void Scale(float value) { *this = Scaling(value) * *this; }
    void Scale(float x, float y) { *this = Scaling(x, y) * *this; }
    void Scale(const SizeF& scaling) { *this = Scaling(scaling) * *this; }
    void Scale(float value, const PointF& origin) { *this = Scaling(value, origin) * *this; }
    void Scale(float x, float y, const PointF& origin) { *this = Scaling(x, y, origin) * *this; }
    void Scale(const SizeF& scaling, const PointF& origin) { *this = Scaling(scaling, origin) * *this; }
 
    static Matrix Rotation(double radians) {
        float sina = static_cast<float>(std::sin(radians));
        float cosa = static_cast<float>(std::cos(radians));
        return Matrix(cosa, sina, -sina, cosa, 0.f, 0.f);
    }
    static Matrix Rotation(double radians, const PointF& origin) {
        float sina = static_cast<float>(std::sin(radians));
        float cosa = static_cast<float>(std::cos(radians));
        float dx = origin.x * (1.f - cosa) + origin.y * sina;
        float dy = origin.y * (1.f - cosa) - origin.x * sina;
        return Matrix(cosa, sina, -sina, cosa, dx, dy);
    }
 
    void Rotate(double radians) { *this = Rotation(radians) * *this; }
    void Rotate(double radians, const PointF& origin) { *this = Rotation(radians, origin) * *this; }
 
    static Matrix RotationDegree(double degree) {
        PointF zero(0.f, 0.f);
        return RotationDegree(degree, zero);
    }
    static Matrix RotationDegree(double degree, const PointF& origin) {
        float sina;
        float cosa;
        if (degree == 0.0) {
            sina = 0.f;
            cosa = 1.f;
        } else if (degree == 90.0) {
            sina = 1.f;
            cosa = 0.f;
        } else if (degree == 180.0) {
            sina = 0.f;
            cosa = -1.f;
        } else if (degree == 270.0) {
            sina = -1.f;
            cosa = 0.f;
        } else {
            double radians = Math::DegreeToRadian(degree);
            sina = static_cast<float>(std::sin(radians));
            cosa = static_cast<float>(std::cos(radians));
        }
 
        float dx = origin.x * (1.f - cosa) + origin.y * sina;
        float dy = origin.y * (1.f - cosa) - origin.x * sina;
        return Matrix(cosa, sina, -sina, cosa, dx, dy);
    }
 
    void RotateDegree(double degree) { *this = RotationDegree(degree) * *this; }
    void RotateDegree(double degree, const PointF& origin) { *this = RotationDegree(degree, origin) * *this; }
 
    static Matrix ReflectionX(float width = 0.f) { return Matrix(-1.f, 0.f, 0.f, 1.f, 0.f, width); }
    static Matrix ReflectionY(float height = 0.f) { return Matrix(1.f, 0.f, 0.f, -1.f, 0.f, height); }
 
    void ReflectX(float width = 0.f) { *this = ReflectionX(width) * *this; }
    void ReflectY(float height = 0.f) { *this = ReflectionY(height) * *this; }
 
    bool IsReflected() const {
        return a * d < b * c;
    }
 
    static Matrix Translation(float x, float y) { return Matrix(1.f, 0.f, 0.f, 1.f, x, y); }
    static Matrix Translation(const PointF& v) { return Translation(v.x, v.y); }
 
    void Translate(float x, float y) { *this = Translation(x, y) * *this; }
    void Translate(const PointF& v) { *this = Translation(v) * *this; }
 
    bool IsInvertible() const {
        double det = Determinant();
        static constexpr double EPS = std::numeric_limits<double>::epsilon();
        return (det < -EPS || det > EPS);
    }
 
#ifndef SWIG
    std::optional<Matrix> Inverse() const {
        double det = Determinant();
 
        static constexpr double EPS = std::numeric_limits<double>::epsilon();
        if (det >= -EPS && det <= EPS)
            return std::nullopt;
 
        double invdet = 1.0 / det;
        float A = static_cast<float>(d * invdet);
        float B = static_cast<float>(-b * invdet);
        float C = static_cast<float>(-c * invdet);
        float D = static_cast<float>(a * invdet);
        float E = static_cast<float>((f * c - e * d) * invdet);
        float F = static_cast<float>((e * b - f * a) * invdet);
        return Matrix(A, B, C, D, E, F);
    }
#endif
 
    Matrix InverseOrIdentity() const {
        return Inverse().value_or(Matrix{});
    }
 
    static Matrix RectToRect(const RectF& source, const RectF& dest) {
        float sx = dest.GetWidth() / source.GetWidth();
        float sy = dest.GetHeight() / source.GetHeight();
        float dx = dest.MinX() - sx * source.MinX();
        float dy = dest.MinY() - sy * source.MinY();
        return Matrix(sx, 0.f, 0.f, sy, dx, dy);
    }
 
    static Matrix RectToRectProportional(const RectF& source, const RectF& dest) {
        float sx = dest.GetWidth() / source.GetWidth();
        float sy = dest.GetHeight() / source.GetHeight();
        float scale = (std::min)(sx, sy);
        float dx = dest.MinX() - scale * source.MinX() + (dest.GetWidth() - scale * source.GetWidth()) / 2.0f;
        float dy = dest.MinY() - scale * source.MinY() + (dest.GetHeight() - scale * source.GetHeight()) / 2.0f;
        return Matrix(scale, 0.f, 0.f, scale, dx, dy);
    }
 
    bool DoesPreserveRects() const {
        bool A = !Math::FloatEq(a, 0.0f);
        bool B = !Math::FloatEq(b, 0.0f);
        bool C = !Math::FloatEq(c, 0.0f);
        bool D = !Math::FloatEq(d, 0.0f);
        return (A == D && B == C && A != B && C != D);
    }
};
 
}  // namespace PDF
 
#endif  // PDFSDK_CXX_MATH_H_INCLUDED_