WireRouting/include/Geometry.h

#pragma once

#include <numeric>
#include <limits>
#include <cmath>
#include <vector>

template <typename T>
class Vec3
{
public:
    T a, b, c;

    Vec3(T x = T(), T y = T(), T z = T()) : a(x), b(y), c(z) {} // Ð޸ĺó´úÂë

    T operator[](int i) const
    {
        if (i == 0)
        {
            return a;
        }
        else if (i == 1)
        {
            return b;
        }
        else if (i == 2)
        {
            return c;
        }
        return a;
    }

    T &operator[](int i)
    {
        if (i == 0)
        {
            return a;
        }
        else if (i == 1)
        {
            return b;
        }
        else if (i == 2)
        {
            return c;
        }
        return a;
    }

    //    Vec3 operator+(const Vec3 &other) const {
    //        return {a + other.a, b + other.b, c + other.c};
    //    }
    Vec3 operator+(const Vec3 &other) const
    {
        return Vec3(a + other.a, b + other.b, c + other.c);
    } // VS2008

    //    Vec3 operator/(const float w) const {
    //        return {a / w, b / w, c / w};
    //    }
    Vec3 operator/(const float w) const
    {
        return Vec3(a / w, b / w, c / w);
    } // VS2008

    //    Vec3 operator-(const Vec3 &other) const {
    //        return {a - other.a, b - other.b, c - other.c};
    //    }
    Vec3 operator-(const Vec3 &other) const
    {
        return Vec3(a - other.a, b - other.b, c - other.c);
    } // VS2008

    //    Vec3 operator*(const float &w) const {
    //        return {a * w, b * w, c * w};
    //    }
    Vec3 operator*(const float &w) const
    {
        return Vec3(a * w, b * w, c * w);
    } // VS2008

    float length() const
    {
        return sqrt(a * a + b * b + c * c);
    }

    Vec3 norm() const
    {
        return *this / length();
    }

    //    Vec3 cross(const Vec3 &other) const {
    //        return {b * other.c - c * other.b, c * other.a - a * other.c, a * other.b - b * other.a};
    //    }
    Vec3 cross(const Vec3 &other) const
    {
        return Vec3(b * other.c - c * other.b, c * other.a - a * other.c, a * other.b - b * other.a);
    }

    float dot(const Vec3 &other) const
    {
        return a * other.a + b * other.b + c * other.c;
    }
};

typedef Vec3<float> Vec3f;
typedef Vec3<unsigned int> Vec3u;

class Mesh
{
public:
    std::vector<Vec3f> vertices;
    std::vector<Vec3u> indices;
};

class AABB
{
public:
    Vec3f min, max;
    /*
        AABB()
            :min(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(),std::numeric_limits<float>::max()),
            max(std::numeric_limits<float>::min(), std::numeric_limits<float>::min(),std::numeric_limits<float>::min())
        {}
    */
    AABB()
    {
        min = Vec3f(1e5, 1e5, 1e5);
        max = Vec3f(0, 0, 0);
    }
};

class LineSegment
{
public:
    Vec3f start;
    Vec3f end;

    //    LineSegment(const Vec3f &s, const Vec3f &e) : start(s), end(e) {
    //        length = (end - start).length();
    //        dir = (end - start).norm();
    //    }
    LineSegment(const Vec3f &s, const Vec3f &e) : start(s), end(e)
    {
        calculate();
    }

    float getLength() const
    {
        return length;
    }

    Vec3f getDir() const
    {
        return dir;
    }

    // private:
    float length;
    Vec3f dir;
    void calculate()
    {                             // VS2008
        Vec3f diff = end - start; // VS2008
        length = diff.length();   // VS2008
        dir = diff.norm();        // VS2008
    } // VS2008
};

struct FaceCenterComparator
{
    const std::vector<Vec3f> &faceCenters; // Ìæ»» YourVectorType ΪÄãµÄÏòÁ¿ÀàÐÍ
    int longAxis;

    FaceCenterComparator(const std::vector<Vec3f> &centers, int axis)
        : faceCenters(centers), longAxis(axis) {}

    bool operator()(const size_t &a, const size_t &b) const
    {
        return faceCenters[a][longAxis] < faceCenters[b][longAxis];
    }
};