WireRouting/include/Geometry.h

#pragma once

#ifdef MY_LIB_SHARED_BUILD
    #ifdef _WIN32
        #ifdef MY_LIB_EXPORTS
            #define LIB_API __declspec(dllexport)
        #else
            #define LIB_API __declspec(dllimport)
        #endif  // MY_LIB_EXPORTS
    #else
        #define LIB_API
    #endif  // _WIN32
#else
    #define LIB_API
#endif  // MY_LIB_SHARED_BUILD

#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 Vec3(a + other.a, b + other.b, c + other.c);
    }

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

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

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

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

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

    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;

extern "C" class LIB_API Mesh
{
public:
    std::vector<Vec3f> vertices;
    std::vector<Vec3u> indices;
};

extern "C" class LIB_API AABB
{
public:
    Vec3f min, max;
    AABB();
};

extern "C" class LIB_API LineSegment
{
public:
    Vec3f start;
    Vec3f end;
    float length;
    Vec3f dir;

    LineSegment(const Vec3f &s, const Vec3f &e);

    float getLength() const;

    Vec3f getDir() const;

    void calculate();
};

extern "C" struct LIB_API FaceCenterComparator
{
    const std::vector<Vec3f> &faceCenters; // �滻 YourVectorType Ϊ������������
    int longAxis;

    FaceCenterComparator(const std::vector<Vec3f> &centers, int axis);

    bool operator()(const size_t &a, const size_t &b) const;
};