CVGeom.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Local
#include <Eigen/Core>
 
#include "CVCoreLib.h"
#include "CVTypes.h"
// clang-format off
#include "Eigen.h"  // Must be included before <vector> to ensure vector specializations
// clang-format on
 
// system
#include <algorithm>
#include <cmath>
#include <limits>
#include <vector>
 
#ifdef _MSC_VER
// To get rid of the warning about unnamed struct/union
#pragma warning(disable : 4201)
#endif
 
template <typename Type>
class Vector2Tpl {
public:
    union {
        struct {
            Type x, y;
        };
        Type u[2];
    };
 
    inline std::size_t rows() const { return dimensions(); }
    inline std::size_t dimensions() const { return 2; }
 
    inline Type* data() { return u; }
    inline const Type* data() const { return u; }
 
 
    inline explicit Vector2Tpl(Type s = 0) : x(s), y(s) {}
 
 
    inline Vector2Tpl(Type _x, Type _y) : x(_x), y(_y) {}
 
    inline Type norm2() const { return (x * x) + (y * y); }
    inline Type norm() const { return std::sqrt(norm2()); }
    inline void normalize() {
        Type n = norm2();
        if (n > 0) *this /= std::sqrt(n);
    }
 
    inline Type dot(const Vector2Tpl& v) const { return (x * v.x) + (y * v.y); }
 
    inline Type cross(const Vector2Tpl& v) const { return x * v.y - y * v.x; }
 
    inline Vector2Tpl& operator-() {
        x = -x;
        y = -y;
        return *this;
    }
    inline Vector2Tpl& operator+=(const Vector2Tpl& v) {
        x += v.x;
        y += v.y;
        return *this;
    }
    inline Vector2Tpl& operator-=(const Vector2Tpl& v) {
        x -= v.x;
        y -= v.y;
        return *this;
    }
    inline Vector2Tpl& operator*=(Type v) {
        x *= v;
        y *= v;
        return *this;
    }
    inline Vector2Tpl& operator/=(Type v) {
        x /= v;
        y /= v;
        return *this;
    }
    inline Vector2Tpl operator+(const Vector2Tpl& v) const {
        return Vector2Tpl(x + v.x, y + v.y);
    }
    inline Vector2Tpl operator-(const Vector2Tpl& v) const {
        return Vector2Tpl(x - v.x, y - v.y);
    }
    inline Vector2Tpl operator*(Type s) const {
        return Vector2Tpl(x * s, y * s);
    }
    inline Vector2Tpl operator/(Type s) const {
        return Vector2Tpl(x / s, y / s);
    }
    inline Type& operator[](unsigned i) { return u[i]; }
    inline const Type& operator[](unsigned i) const { return u[i]; }
};
 
template <class Type>
class Tuple3Tpl {
public:
    // The 3 tuple values as a union (array/separate values)
    union {
        struct {
            Type x, y, z;
        };
        Type u[3];
    };
 
    inline std::size_t rows() const { return dimensions(); }
    inline std::size_t dimensions() const { return 3; }
 
    inline Type* data() { return u; }
    inline const Type* data() const { return u; }
 
 
    inline Tuple3Tpl() : x(0), y(0), z(0) {}
 
 
    inline Tuple3Tpl(Type a, Type b, Type c) : x(a), y(b), z(c) {}
 
    inline explicit Tuple3Tpl(const Type p[]) : x(p[0]), y(p[1]), z(p[2]) {}
 
    inline Tuple3Tpl operator-() const {
        Tuple3Tpl V(-x, -y, -z);
        return V;
    }
    inline Tuple3Tpl& operator+=(const Tuple3Tpl& v) {
        x += v.x;
        y += v.y;
        z += v.z;
        return *this;
    }
    inline Tuple3Tpl& operator-=(const Tuple3Tpl& v) {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        return *this;
    }
    inline Tuple3Tpl& operator*=(Type v) {
        x *= v;
        y *= v;
        z *= v;
        return *this;
    }
    inline Tuple3Tpl& operator/=(Type v) {
        x /= v;
        y /= v;
        z /= v;
        return *this;
    }
    inline Tuple3Tpl operator+(const Tuple3Tpl& v) const {
        return Tuple3Tpl(x + v.x, y + v.y, z + v.z);
    }
    inline Tuple3Tpl operator-(const Tuple3Tpl& v) const {
        return Tuple3Tpl(x - v.x, y - v.y, z - v.z);
    }
    inline Tuple3Tpl operator*(Type s) const {
        return Tuple3Tpl(x * s, y * s, z * s);
    }
    inline Tuple3Tpl operator/(Type s) const {
        return Tuple3Tpl(x / s, y / s, z / s);
    }
};
 
using Tuple3ub = Tuple3Tpl<unsigned char>;
using Tuple3s = Tuple3Tpl<short>;
using Tuple3i = Tuple3Tpl<int>;
using Tuple3ui = Tuple3Tpl<unsigned int>;
 
template <typename Type>
class Vector3Tpl : public Tuple3Tpl<Type> {
public:
    // Don't ask me what other x, y, z or u members this class could
    // use but it seems necessary for compilation on some platforms...
    using Tuple3Tpl<Type>::x;
    using Tuple3Tpl<Type>::y;
    using Tuple3Tpl<Type>::z;
    using Tuple3Tpl<Type>::u;
 
 
    inline Vector3Tpl() : Tuple3Tpl<Type>() {}
 
 
    inline Vector3Tpl(Type _x, Type _y, Type _z)
        : Tuple3Tpl<Type>(_x, _y, _z) {}
 
    inline explicit Vector3Tpl(const Type p[]) : Tuple3Tpl<Type>(p) {}
 
    inline explicit Vector3Tpl(const Vector2Tpl<Type>& t2D, Type c)
        : Tuple3Tpl<Type>(t2D.x, t2D.y, c) {}
 
    operator Vector3Tpl<double>() const { return Vector3Tpl<double>(x, y, z); }
 
    Vector3Tpl<double> toDouble() const { return Vector3Tpl<double>(x, y, z); }
    Vector3Tpl<float> toFloat() const {
        return Vector3Tpl<float>::fromArray(u);
    }
    Vector3Tpl<PointCoordinateType> toPC() const {
        return Vector3Tpl<PointCoordinateType>::fromArray(u);
    }
 
    static inline Vector3Tpl fromArray(const int a[3]) {
        return Vector3Tpl(static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                          static_cast<Type>(a[2]));
    }
    static inline Vector3Tpl fromArray(const float a[3]) {
        return Vector3Tpl(static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                          static_cast<Type>(a[2]));
    }
    static inline Vector3Tpl fromArray(const double a[3]) {
        return Vector3Tpl(static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                          static_cast<Type>(a[2]));
    }
 
    static inline Vector3Tpl fromArray(const Eigen::Matrix<double, 3, 1>& a) {
        return Vector3Tpl(static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                          static_cast<Type>(a[2]));
    }
    static inline Eigen::Matrix<Type, 3, 1> fromArray(
            const Vector3Tpl<float>& a) {
        return Eigen::Matrix<Type, 3, 1>(static_cast<Type>(a[0]),
                                         static_cast<Type>(a[1]),
                                         static_cast<Type>(a[2]));
    }
    static inline Eigen::Matrix<Type, 3, 1> fromArray(
            const Vector3Tpl<double>& a) {
        return Eigen::Matrix<Type, 3, 1>(static_cast<Type>(a[0]),
                                         static_cast<Type>(a[1]),
                                         static_cast<Type>(a[2]));
    }
 
    static inline std::vector<Eigen::Matrix<double, 3, 1>> fromArrayContainer(
            const std::vector<Vector3Tpl<Type>>& container) {
        std::vector<Eigen::Matrix<double, 3, 1>> points;
        points.resize(container.size());
        for (size_t i = 0; i < container.size(); ++i) {
            points[i] = Eigen::Matrix<double, 3, 1>(
                    static_cast<double>(container[i][0]),
                    static_cast<double>(container[i][1]),
                    static_cast<double>(container[i][2]));
        }
        return points;
    }
 
    static inline std::vector<Vector3Tpl> fromArrayContainer(
            const std::vector<Eigen::Matrix<double, 3, 1>>& container) {
        std::vector<Vector3Tpl> points;
        points.resize(container.size());
        for (size_t i = 0; i < container.size(); ++i) {
            points[i] = Vector3Tpl(static_cast<Type>(container[i](0)),
                                   static_cast<Type>(container[i](1)),
                                   static_cast<Type>(container[i](2)));
        }
        return points;
    }
 
    inline Vector3Tpl(const Eigen::Matrix<float, 3, 1>& v) { *this = v; }
    inline Vector3Tpl(const Eigen::Matrix<double, 3, 1>& v) { *this = v; }
 
    inline Vector3Tpl& operator=(const Eigen::Matrix<double, 3, 1>& v) {
        this->x = static_cast<Type>(v(0));
        this->y = static_cast<Type>(v(1));
        this->z = static_cast<Type>(v(2));
        return *this;
    }
    inline Vector3Tpl& operator=(const Eigen::Matrix<float, 3, 1>& v) {
        this->x = static_cast<Type>(v(0));
        this->y = static_cast<Type>(v(1));
        this->z = static_cast<Type>(v(2));
        return *this;
    }
 
    inline Vector3Tpl& operator+=(const Eigen::Matrix<double, 3, 1>& v) {
        x += static_cast<Type>(v(0));
        y += static_cast<Type>(v(1));
        z += static_cast<Type>(v(2));
        return *this;
    }
    inline Vector3Tpl& operator-=(const Eigen::Matrix<double, 3, 1>& v) {
        x -= static_cast<Type>(v(0));
        y -= static_cast<Type>(v(1));
        z -= static_cast<Type>(v(2));
        return *this;
    }
 
    inline Vector3Tpl& operator*=(const Eigen::Matrix<double, 3, 1>& v) {
        *this = *this * v;
        return *this;
    }
 
    inline Vector3Tpl operator-(const Eigen::Matrix<double, 3, 1>& v) const {
        return Vector3Tpl(static_cast<Type>(x - v(0)),
                          static_cast<Type>(y - v(1)),
                          static_cast<Type>(z - v(2)));
    }
 
    inline Vector3Tpl operator+(const Eigen::Matrix<double, 3, 1>& v) const {
        return Vector3Tpl(static_cast<Type>(x + v(0)),
                          static_cast<Type>(y + v(1)),
                          static_cast<Type>(z + v(2)));
    }
 
    inline Vector3Tpl operator*(const Eigen::Matrix<double, 3, 1>& v) const {
        return cross(v);
    }
 
    inline Type operator&&(const Eigen::Matrix<double, 3, 1>& v) const {
        return dot(v);
    }
 
    inline friend std::ostream& operator<<(std::ostream& stream,
                                           const Vector3Tpl& v) {
        stream << "[x->" << v.x << ", y->" << v.y << ", z->" << v.x << "]"
               << std::endl;
        return stream;
    }
 
    inline Type& operator()(unsigned i) { return u[i]; }
    inline const Type& operator()(unsigned i) const { return u[i]; }
 
    inline Type maxCoeff() const {
        return x > y ? (x > z ? x : z) : (y > z ? y : z);
    }
    inline Type prod() const { return std::abs(x * y * z); }
    inline Type dot(const Vector3Tpl& v) const {
        return x * v.x + y * v.y + z * v.z;
    }
    inline Vector3Tpl cross(const Vector3Tpl& v) const {
        return Vector3Tpl((y * v.z) - (z * v.y), (z * v.x) - (x * v.z),
                          (x * v.y) - (y * v.x));
    }
    inline Type norm2() const { return x * x + y * y + z * z; }
    inline double norm2d() const {
        return static_cast<double>(x) * x + static_cast<double>(y) * y +
               static_cast<double>(z) * z;
    }
    inline Type norm() const { return static_cast<Type>(std::sqrt(norm2d())); }
    inline double normd() const { return std::sqrt(norm2d()); }
    inline void normalize() {
        double n = norm2d();
        if (n > 0) *this /= static_cast<Type>(std::sqrt(n));
    }
    inline Vector3Tpl orthogonal() const {
        Vector3Tpl ort;
        vorthogonal(u, ort.u);
        return ort;
    }
 
    inline Vector3Tpl operator-() const {
        Vector3Tpl V(-x, -y, -z);
        return V;
    }
    inline Vector3Tpl& operator+=(const Vector3Tpl& v) {
        x += v.x;
        y += v.y;
        z += v.z;
        return *this;
    }
    inline Vector3Tpl& operator-=(const Vector3Tpl& v) {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        return *this;
    }
    inline Vector3Tpl& operator*=(Type v) {
        x *= v;
        y *= v;
        z *= v;
        return *this;
    }
    inline Vector3Tpl& operator/=(Type v) {
        x /= v;
        y /= v;
        z /= v;
        return *this;
    }
    inline Vector3Tpl operator+(const Vector3Tpl& v) const {
        return Vector3Tpl(x + v.x, y + v.y, z + v.z);
    }
    inline Vector3Tpl operator-(const Vector3Tpl& v) const {
        return Vector3Tpl(x - v.x, y - v.y, z - v.z);
    }
    inline Vector3Tpl operator*(Type s) const {
        return Vector3Tpl(x * s, y * s, z * s);
    }
    inline Vector3Tpl operator/(Type s) const {
        return Vector3Tpl(x / s, y / s, z / s);
    }
    inline Vector3Tpl operator*(const Vector3Tpl& v) const { return cross(v); }
    inline Type operator&&(const Vector3Tpl& v) const { return dot(v); }
    inline Type& operator[](unsigned i) { return u[i]; }
    inline const Type& operator[](unsigned i) const { return u[i]; }
    Type angle_rad(const Vector3Tpl& v) const { return vangle_rad(u, v.u); }
    double angle_radd(const Vector3Tpl& v) const { return vangle_radd(u, v.u); }
 
    static inline void vdivide(const Type p[], Type s, Type r[]) {
        r[0] = p[0] / s;
        r[1] = p[1] / s;
        r[2] = p[2] / s;
    }
    static inline void vdivide(Type p[], Type s) {
        p[0] /= s;
        p[1] /= s;
        p[2] /= s;
    }
    static inline void vmultiply(const Type p[], Type s, Type r[]) {
        r[0] = p[0] * s;
        r[1] = p[1] * s;
        r[2] = p[2] * s;
    }
    static inline void vmultiply(Type p[], Type s) {
        p[0] *= s;
        p[1] *= s;
        p[2] *= s;
    }
    static inline Type vdot(const Type p[], const Type q[]) {
        return (p[0] * q[0]) + (p[1] * q[1]) + (p[2] * q[2]);
    }
    static inline double vdotd(const Type p[], const Type q[]) {
        return (static_cast<double>(p[0]) * q[0]) +
               (static_cast<double>(p[1]) * q[1]) +
               (static_cast<double>(p[2]) * q[2]);
    }
    static inline void vcross(const Type p[], const Type q[], Type r[]) {
        r[0] = (p[1] * q[2]) - (p[2] * q[1]);
        r[1] = (p[2] * q[0]) - (p[0] * q[2]);
        r[2] = (p[0] * q[1]) - (p[1] * q[0]);
    }
    static inline void vcopy(const Type p[], Type q[]) {
        q[0] = p[0];
        q[1] = p[1];
        q[2] = p[2];
    }
    static inline void vset(Type p[], Type s) { p[0] = p[1] = p[2] = s; }
    static inline void vset(Type p[], Type x, Type y, Type z) {
        p[0] = x;
        p[1] = y;
        p[2] = z;
    }
    static inline void vadd(const Type p[], const Type q[], Type r[]) {
        r[0] = p[0] + q[0];
        r[1] = p[1] + q[1];
        r[2] = p[2] + q[2];
    }
    // note misspelling: should be vsubtract
    static inline void vsubstract(const Type p[], const Type q[], Type r[]) {
        r[0] = p[0] - q[0];
        r[1] = p[1] - q[1];
        r[2] = p[2] - q[2];
    }
    static inline void vcombination(
            Type a, const Type p[], Type b, const Type q[], Type r[]) {
        r[0] = (a * p[0]) + (b * q[0]);
        r[1] = (a * p[1]) + (b * q[1]);
        r[2] = (a * p[2]) + (b * q[2]);
    }
    static inline void vcombination(const Type p[],
                                    Type b,
                                    const Type q[],
                                    Type r[]) {
        r[0] = p[0] + (b * q[0]);
        r[1] = p[1] + (b * q[1]);
        r[2] = p[2] + (b * q[2]);
    }
    static inline void vnormalize(Type p[]) {
        Type n = vnorm2(p);
        if (n > 0) vdivide(p, std::sqrt(n));
    }
    static inline Type vnorm2(const Type p[]) {
        return (p[0] * p[0]) + (p[1] * p[1]) + (p[2] * p[2]);
    }
    static inline double vnorm2d(const Type p[]) {
        return (static_cast<double>(p[0]) * p[0]) +
               (static_cast<double>(p[1]) * p[1]) +
               (static_cast<double>(p[2]) * p[2]);
    }
    static inline Type vdistance2(const Type p[], const Type q[]) {
        return ((p[0] - q[0]) * (p[0] - q[0])) +
               ((p[1] - q[1]) * (p[1] - q[1])) +
               ((p[2] - q[2]) * (p[2] - q[2]));
    }
    static inline double vdistance2d(const Type p[], const Type q[]) {
        return ((static_cast<double>(p[0]) - q[0]) *
                (static_cast<double>(p[0]) - q[0])) +
               ((static_cast<double>(p[1]) - q[1]) *
                (static_cast<double>(p[1]) - q[1])) +
               ((static_cast<double>(p[2]) - q[2]) *
                (static_cast<double>(p[2]) - q[2]));
    }
    static inline Type vnorm(const Type p[]) { return std::sqrt(vnorm2(p)); }
    static inline double vnormd(const Type p[]) {
        return std::sqrt(vnorm2d(p));
    }
    static inline Type vdistance(const Type p[], const Type q[]) {
        return std::sqrt(vdistance2(p, q));
    }
    static inline double vdistanced(const Type p[], const Type q[]) {
        return std::sqrt(vdistance2d(p, q));
    }
 
    static inline void vorthogonal(const Type p[], Type q[]) {
        if (std::abs(p[0]) <= std::abs(p[1]) &&
            std::abs(p[0]) <= std::abs(p[2])) {
            q[0] = 0;
            q[1] = p[2];
            q[2] = -p[1];
        } else if (std::abs(p[1]) <= std::abs(p[0]) &&
                   std::abs(p[1]) <= std::abs(p[2])) {
            q[0] = -p[2];
            q[1] = 0;
            q[2] = p[0];
        } else {
            q[0] = p[1];
            q[1] = -p[0];
            q[2] = 0;
        }
        vnormalize(q);
    }
 
    static Type vangle_rad(const Type p[], const Type q[]) {
        Type productNorm = vnorm(p) * vnorm(q);
        if (productNorm < std::numeric_limits<Type>::epsilon()) {
            return std::numeric_limits<Type>::quiet_NaN();
        }
 
        Type cosAngle = vdot(p, q) / productNorm;
        return acos(std::max(std::min(cosAngle, static_cast<Type>(1.0)),
                             static_cast<Type>(-1.0)));
    }
 
    static double vangle_radd(const Type p[], const Type q[]) {
        double productNorm = vnormd(p) * vnormd(q);
        if (productNorm < std::numeric_limits<double>::epsilon()) {
            return std::numeric_limits<double>::quiet_NaN();
        }
 
        double cosAngle = vdotd(p, q) / productNorm;
        return acos(std::max(std::min(cosAngle, 1.0), -1.0));
    }
};
 
template <class Type>
class Tuple4Tpl {
public:
    // The 4 tuple values as a union (array/separate values)
    union {
        struct {
            Type x, y, z, w;
        };
        Type u[4];
    };
 
    inline std::size_t rows() const { return dimensions(); }
    inline std::size_t dimensions() const { return 4; }
 
    inline Type* data() { return u; }
    inline const Type* data() const { return u; }
 
 
    inline Tuple4Tpl() : x(0), y(0), z(0), w(0) {}
 
 
    inline Tuple4Tpl(Type a, Type b, Type c, Type d) : x(a), y(b), z(c), w(d) {}
 
    inline explicit Tuple4Tpl(const Type p[])
        : x(p[0]), y(p[1]), z(p[2]), w(p[3]) {}
 
    static inline Tuple4Tpl fromArray(const Eigen::Matrix<Type, 4, 1>& a) {
        return Tuple4Tpl(static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                         static_cast<Type>(a[2]), static_cast<Type>(a[3]));
    }
    static inline Eigen::Matrix<Type, 4, 1> fromArray(
            const Tuple4Tpl<float>& a) {
        return Eigen::Matrix<Type, 4, 1>(
                static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                static_cast<Type>(a[2]), static_cast<Type>(a[3]));
    }
    static inline Eigen::Matrix<Type, 4, 1> fromArray(
            const Tuple4Tpl<double>& a) {
        return Eigen::Matrix<Type, 4, 1>(
                static_cast<Type>(a[0]), static_cast<Type>(a[1]),
                static_cast<Type>(a[2]), static_cast<Type>(a[3]));
    }
 
    inline Tuple4Tpl(const Eigen::Matrix<float, 4, 1>& v) { *this = v; }
    inline Tuple4Tpl(const Eigen::Matrix<double, 4, 1>& v) { *this = v; }
    inline Tuple4Tpl& operator=(const Eigen::Matrix<float, 4, 1>& v) {
        this->x = static_cast<Type>(v(0));
        this->y = static_cast<Type>(v(1));
        this->z = static_cast<Type>(v(2));
        this->w = static_cast<Type>(v(3));
        return *this;
    }
    inline Tuple4Tpl& operator=(const Eigen::Matrix<double, 4, 1>& v) {
        this->x = static_cast<Type>(v(0));
        this->y = static_cast<Type>(v(1));
        this->z = static_cast<Type>(v(2));
        this->w = static_cast<Type>(v(3));
        return *this;
    }
 
    inline Tuple4Tpl operator-() const {
        Tuple4Tpl V(-x, -y, -z, -w);
        return V;
    }
    inline Tuple4Tpl& operator+=(const Tuple4Tpl& v) {
        x += v.x;
        y += v.y;
        z += v.z;
        w += v.w;
        return *this;
    }
    inline Tuple4Tpl& operator-=(const Tuple4Tpl& v) {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        w -= v.w;
        return *this;
    }
    inline Tuple4Tpl& operator*=(Type v) {
        x *= v;
        y *= v;
        z *= v;
        w *= v;
        return *this;
    }
    inline Tuple4Tpl& operator/=(Type v) {
        x /= v;
        y /= v;
        z /= v;
        w /= v;
        return *this;
    }
    inline Tuple4Tpl operator+(const Tuple4Tpl& v) const {
        return Tuple4Tpl(x + v.x, y + v.y, z + v.z, w + v.w);
    }
    inline Tuple4Tpl operator-(const Tuple4Tpl& v) const {
        return Tuple4Tpl(x - v.x, y - v.y, z - v.z, w - v.w);
    }
    inline Tuple4Tpl operator*(Type s) const {
        return Tuple4Tpl(x * s, y * s, z * s, w * s);
    }
    inline Tuple4Tpl operator/(Type s) const {
        return Tuple4Tpl(x / s, y / s, z / s, w / s);
    }
 
    inline Type& operator[](unsigned i) { return u[i]; }
    inline const Type& operator[](unsigned i) const { return u[i]; }
    inline Type& operator()(unsigned i) { return u[i]; }
    inline const Type& operator()(unsigned i) const { return u[i]; }
};
 
using CCVector2 = Vector2Tpl<PointCoordinateType>;
 
using CCVector2d = Vector2Tpl<double>;
 
using CCVector2i = Vector2Tpl<int>;
 
inline Vector3Tpl<float> operator*(float s, const Vector3Tpl<float>& v) {
    return v * s;
}
// Multiplication of a 3D vector by a scalar (front) operator (double version)
inline Vector3Tpl<double> operator*(double s, const Vector3Tpl<double>& v) {
    return v * s;
}
 
using CCVector3 = Vector3Tpl<PointCoordinateType>;
 
using CCVector3f = Vector3Tpl<float>;
 
using CCVector3d = Vector3Tpl<double>;
 
using CCVector3i = Vector3Tpl<int>;
 
#ifdef _MSC_VER
// Restore the default warning behavior
#pragma warning(default : 4201)
#endif