/***************************************************************************
 *   Copyright (c) 2005 Imetric 3D GmbH                                    *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef BASE_BOUNDBOX_H
#define BASE_BOUNDBOX_H

#include <array>
#include <limits>
#include "Matrix.h"
#include "Tools2D.h"
#include "ViewProj.h"


namespace Base {

class ViewProjMethod;

/** The 3D bounding box class. */
template <class Precision>
class BoundBox3
{
    // helper function
    static bool isOnRayW(Precision min, Precision max, Precision val);
    static bool isOnRayS(Precision min, Precision max, Precision val);

public:
    using num_type = Precision;
    using traits_type = float_traits<num_type>;

    /**  Public attributes */
    //@{
    Precision MinX;
    Precision MinY;
    Precision MinZ;
    Precision MaxX;
    Precision MaxY;
    Precision MaxZ;
    //@}

    /** Builds box from pairs of x,y,z values. */
    inline explicit BoundBox3 (Precision fMinX =  std::numeric_limits<Precision>::max(),
                               Precision fMinY =  std::numeric_limits<Precision>::max(),
                               Precision fMinZ =  std::numeric_limits<Precision>::max(),
                               Precision fMaxX = -std::numeric_limits<Precision>::max(),
                               Precision fMaxY = -std::numeric_limits<Precision>::max(),
                               Precision fMaxZ = -std::numeric_limits<Precision>::max());
    BoundBox3 (const BoundBox3<Precision> &rcBB) = default;
    BoundBox3 (BoundBox3<Precision> &&rcBB) noexcept = default;
    /** Builds box from an array of points. */
    inline BoundBox3 (const Vector3<Precision> *pclVect, std::size_t ulCt);

    /** Defines a bounding box around the center \a rcCnt with the
     * distances \a fDistance in each coordinate.
     */
    BoundBox3 (const Vector3<Precision>& point, Precision distance);
    ~BoundBox3 ();

    /// Assignment operator
    inline  BoundBox3<Precision>& operator = (const BoundBox3<Precision> &rcBound) = default;
    inline  BoundBox3<Precision>& operator = (BoundBox3<Precision> &&rcBound) noexcept = default;

    /** Methods for intersection, cuttíng and union of bounding boxes */
    //@{
    /** Checks for intersection. */
    inline bool Intersect (const BoundBox3<Precision> &rcBB) const;
    /** Checks for intersection. */
    inline bool operator && (const BoundBox3<Precision> &rcBB) const;
    /** Checks for intersection. */
    inline bool Intersect (const BoundBox2d &rcBB) const;
    /** Checks for intersection. */
    inline bool operator && (const BoundBox2d &rcBB) const;
    /** Computes the intersection between two bounding boxes.
    * The result is also a bounding box.
    */
    BoundBox3<Precision> Intersected (const BoundBox3<Precision> &rcBB) const;
    /** The union of two bounding boxes. */
    BoundBox3<Precision> United (const BoundBox3<Precision> &rcBB) const;
    /** Appends the point to the box. The box can grow but not shrink. */
    inline  void Add (const Vector3<Precision> &rclVect);
    /** Appends the bounding box to this box. The box can grow but not shrink. */
    inline  void Add (const BoundBox3<Precision> &rcBB);
    //@}

    /** Test methods */
    //@{
    /** Checks if this point lies inside the box.
     * @note It's up to the client programmer to make sure that this bounding box is valid.
     */
    inline bool IsInBox (const Vector3<Precision> &rcVct) const;
    /** Checks if this 3D box lies inside the box.
     * @note It's up to the client programmer to make sure that both bounding boxes are valid.
     */
    inline bool IsInBox (const BoundBox3<Precision> &rcBB) const;
    /** Checks if this 2D box lies inside the box.
     * @note It's up to the client programmer to make sure that both bounding boxes are valid.
     */
    inline bool IsInBox (const BoundBox2d &rcbb) const;
    /** Checks whether the bounding box is valid. */
    bool IsValid () const;
    //@}

    enum OCTANT {OCT_LDB = 0, OCT_RDB, OCT_LUB, OCT_RUB,
                 OCT_LDF,     OCT_RDF, OCT_LUF, OCT_RUF};
    bool GetOctantFromVector (const Vector3<Precision> &rclVct, OCTANT &rclOctant) const;
    BoundBox3<Precision> CalcOctant (typename BoundBox3<Precision>::OCTANT Octant) const;

    enum SIDE { LEFT =0, RIGHT=1, TOP=2, BOTTOM=3, FRONT=4, BACK=5, INVALID=255 };
    enum CORNER {
        TLB = 0, // top-left-back
        TLF = 1, // top-left-front
        TRF = 2, // top-right-front
        TRB = 3, // top-right-back
        BLB = 4, // bottom-left-back
        BLF = 5, // bottom-left-front
        BRF = 6, // bottom-right-front
        BRB = 7, // bottom-right-back
    };
    enum EDGE {
        TLB_TLF = 0,
        TLF_TRF = 1,
        TRF_TRB = 2,
        TRB_TLB = 3,
        BLB_BLF = 4,
        BLF_BRF = 5,
        BRF_BRB = 6,
        BRB_BLB = 7,
        TLB_BLB = 8,
        TLF_BLF = 9,
        TRF_BRF = 10,
        TRB_BRB = 11
    };

    /**
     * Returns the corner point \a usPoint.
     */
    inline Vector3<Precision> CalcPoint (unsigned short usPoint) const;
    /** Returns the plane of the given side. */
    void CalcPlane (unsigned short usPlane, Vector3<Precision>& rBase,
                    Vector3<Precision>& rNormal) const;
    /** Calculates the two points of an edge.
     */
    bool  CalcEdge (unsigned short usEdge, Vector3<Precision>& rcP0, Vector3<Precision>& rcP1) const;
    /** Intersection point of an inner search ray with the bounding box, built of
     * the base \a rcVct and the direction \a rcVctDir. \a rcVct must lie inside the
     * bounding box.
     */
    bool IntersectionPoint (const Vector3<Precision> &rcVct,
                            const Vector3<Precision> &rcVctDir,
                            Vector3<Precision>& cVctRes,
                            Precision epsilon) const;
    /** Checks for intersection with line incl. search tolerance. */
    bool IsCutLine (const Vector3<Precision>& rcBase,
                    const Vector3<Precision>& rcDir,
                    Precision fTolerance = 0.0F) const;
    /** Checks if this plane specified by (point,normal) cuts this box.
     * @note It's up to the client programmer to make sure that this bounding box is valid.
     */
    inline bool IsCutPlane (const Vector3<Precision> &rclBase,
                            const Vector3<Precision> &rclNormal) const;
    /** Computes the intersection points of line and bounding box. */
    bool IntersectWithLine (const Vector3<Precision>& rcBase,
                            const Vector3<Precision>& rcDir,
                            Vector3<Precision>& rcP0,
                            Vector3<Precision>& rcP1) const;
    /** Computes the intersection point of line and a plane of the bounding box. */
    bool IntersectPlaneWithLine (unsigned short usSide,
                                 const Vector3<Precision>& rcBase,
                                 const Vector3<Precision>& rcDir,
                                 Vector3<Precision>& rcP0) const;
    /** Returns the side of the bounding box the ray exits. */
    typename BoundBox3<Precision>::SIDE GetSideFromRay (const Vector3<Precision> &rclPt,
                                                        const Vector3<Precision> &rclDir) const;
    /** Returns the side of the bounding box the ray exits. */
    typename BoundBox3<Precision>::SIDE GetSideFromRay (const Vector3<Precision> &rclPt,
                                                        const Vector3<Precision> &rclDir,
                                                        Vector3<Precision>& rcInt) const;

    /**
     * Searches for the closest point of the bounding box.
     */
    Vector3<Precision> ClosestPoint (const Vector3<Precision> &rclPt) const;
    /** Projects the box onto a plane and returns a 2D box. */
    BoundBox2d ProjectBox(const ViewProjMethod* proj) const;
    /** Transform the corners of this box with the given matrix and create a new bounding box.
     * @note It's up to the client programmer to make sure that this bounding box is valid.
     */
    BoundBox3<Precision> Transformed(const Matrix4D& mat) const;

    /** Returns the center of the box. */
    inline Vector3<Precision> GetCenter () const;
    /** Returns the minimum point of the box. */
    inline Vector3<Precision> GetMinimum () const;
    /** Returns the maximum point of the box. */
    inline Vector3<Precision> GetMaximum () const;
    /** Compute the diagonal length of this bounding box.
     * @note It's up to the client programmer to make sure that this bounding box is valid.
     */
    inline Precision CalcDiagonalLength () const;
    void SetVoid ();

    /** Enlarges the box with \a fLen. */
    inline void Enlarge (Precision fLen);
    /** Shrinks the box with \a fLen. */
    inline void Shrink  (Precision fLen);

    /** Calculates expansion in x-direction. */
    inline Precision LengthX () const;
    /** Calculates expansion in y-direction. */
    inline Precision LengthY () const;
    /** Calculates expansion in z-direction. */
    inline Precision LengthZ () const;
    /** Calculates the volume. If the box is invalid a negative value is returned */
    inline Precision Volume () const;
    /** Moves in x-direction. */
    inline void MoveX (Precision value);
    /** Moves in y-direction. */
    inline void MoveY (Precision value);
    /** Moves in z-direction. */
    inline void MoveZ (Precision value);
    /** Scales in x-direction. */
    inline void ScaleX (Precision value);
    /** Scales in y-direction. */
    inline void ScaleY (Precision value);
    /** Scales in z-direction. */
    inline void ScaleZ (Precision value);

    /** Prints the values to stream. */
    void Print (std::ostream&) const;
};


template <class Precision>
bool BoundBox3<Precision>::isOnRayW(Precision min, Precision max, Precision val)
{
    // Checks if point val lies on the ray [min,max]
    return ((min <= val) && (val <= max));
}

template <class Precision>
bool BoundBox3<Precision>::isOnRayS(Precision min, Precision max, Precision val)
{
    // Checks if point val lies on the ray [min,max[
    return ((min <= val) && (val < max));
}

// NOLINTBEGIN(bugprone-easily-swappable-parameters)
template <class Precision>
inline BoundBox3<Precision>::BoundBox3 (Precision fMinX, Precision fMinY, Precision fMinZ,
                                        Precision fMaxX, Precision fMaxY, Precision fMaxZ)
  : MinX(fMinX), MinY(fMinY), MinZ(fMinZ),
    MaxX(fMaxX), MaxY(fMaxY), MaxZ(fMaxZ)
{
}
// NOLINTEND(bugprone-easily-swappable-parameters)

template <class Precision>
inline BoundBox3<Precision>::BoundBox3 (const Vector3<Precision> *pclVect, std::size_t ulCt)
  : MinX( std::numeric_limits<Precision>::max())
  , MinY( std::numeric_limits<Precision>::max())
  , MinZ( std::numeric_limits<Precision>::max())
  , MaxX(-std::numeric_limits<Precision>::max())
  , MaxY(-std::numeric_limits<Precision>::max())
  , MaxZ(-std::numeric_limits<Precision>::max())
{
    const Vector3<Precision> *pI = nullptr;
    const Vector3<Precision> *pEnd = pclVect + ulCt;
    for (pI = pclVect; pI < pEnd; ++pI) {
        MinX = std::min<Precision>(MinX, pI->x);
        MinY = std::min<Precision>(MinY, pI->y);
        MinZ = std::min<Precision>(MinZ, pI->z);
        MaxX = std::max<Precision>(MaxX, pI->x);
        MaxY = std::max<Precision>(MaxY, pI->y);
        MaxZ = std::max<Precision>(MaxZ, pI->z);
    }
}

template <class Precision>
inline BoundBox3<Precision>::BoundBox3 (const Vector3<Precision>& point, Precision distance)
    : MinX(point.x - distance)
    , MinY(point.y - distance)
    , MinZ(point.z - distance)
    , MaxX(point.x + distance)
    , MaxY(point.y + distance)
    , MaxZ(point.z + distance)
{
}

template <class Precision>
inline BoundBox3<Precision>::~BoundBox3 () = default;

template <class Precision>
inline bool BoundBox3<Precision>::Intersect (const BoundBox3<Precision> &rcBB) const
{
    if (rcBB.MaxX < this->MinX || rcBB.MinX > this->MaxX) {
        return false;
    }
    if (rcBB.MaxY < this->MinY || rcBB.MinY > this->MaxY) {
        return false;
    }
    if (rcBB.MaxZ < this->MinZ || rcBB.MinZ > this->MaxZ) {
        return false;
    }
    return true;
}

template <class Precision>
bool BoundBox3<Precision>::operator && (const BoundBox3<Precision> &rcBB) const
{
    return Intersect(rcBB);
}

template <class Precision>
inline bool BoundBox3<Precision>::Intersect (const BoundBox2d &rcBB) const
{
    if (rcBB.MaxX < this->MinX || rcBB.MinX > this->MaxX) {
        return false;
    }
    if (rcBB.MaxY < this->MinY || rcBB.MinY > this->MaxY) {
        return false;
    }
    return true;
}

template <class Precision>
inline bool BoundBox3<Precision>::operator && (const BoundBox2d &rcBB) const
{
    return Intersect(rcBB);
}

template <class Precision>
inline BoundBox3<Precision>
BoundBox3<Precision>::Intersected(const BoundBox3<Precision> &rcBB) const
{
    BoundBox3<Precision> cBBRes;

    cBBRes.MinX = std::max<Precision> (MinX, rcBB.MinX);
    cBBRes.MaxX = std::min<Precision> (MaxX, rcBB.MaxX);
    cBBRes.MinY = std::max<Precision> (MinY, rcBB.MinY);
    cBBRes.MaxY = std::min<Precision> (MaxY, rcBB.MaxY);
    cBBRes.MinZ = std::max<Precision> (MinZ, rcBB.MinZ);
    cBBRes.MaxZ = std::min<Precision> (MaxZ, rcBB.MaxZ);

    return cBBRes;
}

template <class Precision>
inline BoundBox3<Precision> BoundBox3<Precision>::United(const BoundBox3<Precision> &rcBB) const
{
    BoundBox3<Precision> cBBRes;

    cBBRes.MinX = std::min<Precision> (MinX, rcBB.MinX);
    cBBRes.MaxX = std::max<Precision> (MaxX, rcBB.MaxX);
    cBBRes.MinY = std::min<Precision> (MinY, rcBB.MinY);
    cBBRes.MaxY = std::max<Precision> (MaxY, rcBB.MaxY);
    cBBRes.MinZ = std::min<Precision> (MinZ, rcBB.MinZ);
    cBBRes.MaxZ = std::max<Precision> (MaxZ, rcBB.MaxZ);

    return cBBRes;
}

template <class Precision>
inline  void BoundBox3<Precision>::Add (const Vector3<Precision> &rclVect)
{
    this->MinX = std::min<Precision>(this->MinX, rclVect.x);
    this->MinY = std::min<Precision>(this->MinY, rclVect.y);
    this->MinZ = std::min<Precision>(this->MinZ, rclVect.z);
    this->MaxX = std::max<Precision>(this->MaxX, rclVect.x);
    this->MaxY = std::max<Precision>(this->MaxY, rclVect.y);
    this->MaxZ = std::max<Precision>(this->MaxZ, rclVect.z);
}

template <class Precision>
inline  void BoundBox3<Precision>::Add (const BoundBox3<Precision> &rcBB)
{
    this->MinX = std::min<Precision> (this->MinX, rcBB.MinX);
    this->MaxX = std::max<Precision> (this->MaxX, rcBB.MaxX);
    this->MinY = std::min<Precision> (this->MinY, rcBB.MinY);
    this->MaxY = std::max<Precision> (this->MaxY, rcBB.MaxY);
    this->MinZ = std::min<Precision> (this->MinZ, rcBB.MinZ);
    this->MaxZ = std::max<Precision> (this->MaxZ, rcBB.MaxZ);
}

template <class Precision>
inline bool BoundBox3<Precision>::IsInBox (const Vector3<Precision> &rcVct) const
{
    if (rcVct.x < this->MinX || rcVct.x > this->MaxX) {
        return false;
    }
    if (rcVct.y < this->MinY || rcVct.y > this->MaxY) {
        return false;
    }
    if (rcVct.z < this->MinZ || rcVct.z > this->MaxZ) {
        return false;
    }
    return true;
}

template <class Precision>
inline bool BoundBox3<Precision>::IsInBox (const BoundBox3<Precision> &rcBB) const
{
    if (rcBB.MinX < this->MinX || rcBB.MaxX > this->MaxX) {
        return false;
    }
    if (rcBB.MinY < this->MinY || rcBB.MaxY > this->MaxY) {
        return false;
    }
    if (rcBB.MinZ < this->MinZ || rcBB.MaxZ > this->MaxZ) {
        return false;
    }
    return true;
}

template <class Precision>
inline bool BoundBox3<Precision>::IsInBox (const BoundBox2d &rcBB) const
{
    if (rcBB.MinX < this->MinX || rcBB.MaxX > this->MaxX) {
        return false;
    }
    if (rcBB.MinY < this->MinY || rcBB.MaxY > this->MaxY) {
        return false;
    }
    return true;
}

template <class Precision>
inline bool BoundBox3<Precision>::IsValid () const
{
    return ((MinX <= MaxX) && (MinY <= MaxY) && (MinZ <= MaxZ));
}

template <class Precision>
inline bool BoundBox3<Precision>::GetOctantFromVector (const Vector3<Precision> &rclVct,
                                                       OCTANT &rclOctant) const
{
    if (!IsInBox (rclVct)) {
        return false;
    }

    unsigned short usNdx = 0;
    if (isOnRayS ((MinX + MaxX)/2, MaxX, rclVct.x)) { // left/RIGHT
        usNdx |= 1;
    }
    if (isOnRayS ((MinY + MaxY)/2, MaxY, rclVct.y)) { // down/UP
        usNdx |= 2;
    }
    if (isOnRayS ((MinZ + MaxZ)/2, MaxZ, rclVct.z)) { // back/FRONT
        usNdx |= 4;
    }
    rclOctant = static_cast<OCTANT>(usNdx);
    return true;
}

template <class Precision>
inline BoundBox3<Precision>
BoundBox3<Precision>::CalcOctant (typename BoundBox3< Precision >::OCTANT Octant) const
{
    BoundBox3<Precision> cOct (*this);

    switch (Octant) {
    case OCT_LDB:
        cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_RDB:
        cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_LUB:
        cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_RUB:
        cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MaxZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_LDF:
        cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_RDF:
        cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MaxY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_LUF:
        cOct.MaxX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;

    case OCT_RUF:
        cOct.MinX = (cOct.MinX + cOct.MaxX)/2;
        cOct.MinY = (cOct.MinY + cOct.MaxY)/2;
        cOct.MinZ = (cOct.MinZ + cOct.MaxZ)/2;
        break;
    }
    return cOct;
}

template <class Precision>
inline Vector3<Precision> BoundBox3<Precision>::CalcPoint (unsigned short usPoint) const
{
    switch (usPoint) {
    case TLB: return Vector3<Precision>(MinX, MinY, MaxZ);
    case TLF: return Vector3<Precision>(MaxX, MinY, MaxZ);
    case TRF: return Vector3<Precision>(MaxX, MaxY, MaxZ);
    case TRB: return Vector3<Precision>(MinX, MaxY, MaxZ);
    case BLB: return Vector3<Precision>(MinX, MinY, MinZ);
    case BLF: return Vector3<Precision>(MaxX, MinY, MinZ);
    case BRF: return Vector3<Precision>(MaxX, MaxY, MinZ);
    case BRB: return Vector3<Precision>(MinX, MaxY, MinZ);
    }

    return Vector3<Precision>();
}

// NOLINTBEGIN(bugprone-easily-swappable-parameters)
template <class Precision>
inline void BoundBox3<Precision>::CalcPlane (unsigned short usPlane,
                                             Vector3<Precision>& rBase,
                                             Vector3<Precision>& rNormal) const
// NOLINTEND(bugprone-easily-swappable-parameters)
{
    switch (usPlane) {
    case LEFT:
        rBase.Set(MinX, MinY, MaxZ);
        rNormal.Set(1.0F, 0.0F, 0.0F);
        break;

    case RIGHT:
        rBase.Set(MaxX, MinY, MaxZ);
        rNormal.Set(1.0F, 0.0F, 0.0F);
        break;

    case TOP:
        rBase.Set(MinX, MaxY, MaxZ);
        rNormal.Set(0.0F, 1.0F, 0.0F);
        break;

    case BOTTOM:
        rBase.Set(MinX, MinY, MaxZ);
        rNormal.Set(0.0F, 1.0F, 0.0F);
        break;

    case FRONT:
        rBase.Set(MinX, MinY, MaxZ);
        rNormal.Set(0.0F, 0.0F, 1.0F);
        break;

    case BACK:
        rBase.Set(MinX, MinY, MinZ);
        rNormal.Set(0.0F, 0.0F, 1.0F);
        break;
    default:
        break;
    }
}

template <class Precision>
inline bool BoundBox3<Precision>::CalcEdge (unsigned short usEdge, Vector3<Precision>& rcP0,
                                            Vector3<Precision>& rcP1) const
{
    switch (usEdge) {
    case TLB_TLF:
        rcP0 = CalcPoint(TLB);
        rcP1 = CalcPoint(TLF);
        break;
    case TLF_TRF:
        rcP0 = CalcPoint(TLF);
        rcP1 = CalcPoint(TRF);
        break;
    case TRF_TRB:
        rcP0 = CalcPoint(TRF);
        rcP1 = CalcPoint(TRB);
        break;
    case TRB_TLB:
        rcP0 = CalcPoint(TRB);
        rcP1 = CalcPoint(TLB);
        break;
    case BLB_BLF:
        rcP0 = CalcPoint(BLB);
        rcP1 = CalcPoint(BLF);
        break;
    case BLF_BRF:
        rcP0 = CalcPoint(BLF);
        rcP1 = CalcPoint(BRF);
        break;
    case BRF_BRB:
        rcP0 = CalcPoint(BRF);
        rcP1 = CalcPoint(BRB);
        break;
    case BRB_BLB:
        rcP0 = CalcPoint(BRB);
        rcP1 = CalcPoint(BLB);
        break;
    case TLB_BLB:
        rcP0 = CalcPoint(TLB);
        rcP1 = CalcPoint(BLB);
        break;
    case TLF_BLF:
        rcP0 = CalcPoint(TLF);
        rcP1 = CalcPoint(BLF);
        break;
    case TRF_BRF:
        rcP0 = CalcPoint(TRF);
        rcP1 = CalcPoint(BRF);
        break;
    case TRB_BRB:
        rcP0 = CalcPoint(TRB);
        rcP1 = CalcPoint(BRB);
        break;
    default:
        return false; // undefined
    }

    return true;
}

template <class Precision>
inline bool BoundBox3<Precision>::IntersectionPoint (const Vector3<Precision> &rcVct,
                                                     const Vector3<Precision> &rcVctDir,
                                                     Vector3<Precision>& cVctRes,
                                                     Precision epsilon) const
{
    const unsigned short num = 6;
    bool rc=false;
    BoundBox3<Precision> cCmpBound(*this);

    // enlarge bounding box by epsilon
    cCmpBound.Enlarge(epsilon);

    // Is point inside?
    if (cCmpBound.IsInBox (rcVct)) {
        // test sides
        for (unsigned short i = 0; (i < num) && (!rc); i++) {
            rc = IntersectPlaneWithLine(i, rcVct, rcVctDir, cVctRes);

            if (!cCmpBound.IsInBox(cVctRes)) {
                rc = false;
            }

            if (rc) {
                // does intersection point lie in desired direction
                // or was found the opposing side?
                // -> scalar product of both direction vectors > 0 (angle < 90)
                rc = ((cVctRes - rcVct) * rcVctDir) >= 0.0;
            }
        }
    }

    return rc;
}

template <class Precision>
inline bool BoundBox3<Precision>::IsCutLine (const Vector3<Precision>& rcBase,
                                             const Vector3<Precision>& rcDir,
                                             Precision fTolerance) const
{
    const unsigned short num = 6;
    Precision fDist;

    // at first only a rough and quick test by the
    // Distance of the line to the center of the BB is calculated
    // and with the maximum diagonal length + fTolerance
    // will be compared.

    // Distance between center point and line
    fDist = (rcDir % (GetCenter() - rcBase)).Length() / rcDir.Length();

    if (fDist > (CalcDiagonalLength() + fTolerance)) {
        return false;
    }

    // more detailed test here
    Vector3<Precision>  clVectRes;

    // intersect each face with the line
    for (unsigned short i = 0; i < num; i++) {
        if (IntersectPlaneWithLine(i, rcBase, rcDir, clVectRes)) {
            // Check whether the intersection point is within BB limits + Tolerance
            switch (i) {
                case LEFT :  // left and right plane
                case RIGHT :
                    if ((isOnRayW (MinY - fTolerance, MaxY + fTolerance, clVectRes.y) &&
                         isOnRayW (MinZ - fTolerance, MaxZ + fTolerance, clVectRes.z))) {
                        return true;
                    }
                    break;
                case TOP :  // top and bottom plane
                case BOTTOM :
                    if ((isOnRayW (MinX - fTolerance, MaxX + fTolerance, clVectRes.x) &&
                         isOnRayW (MinZ - fTolerance, MaxZ + fTolerance, clVectRes.z))) {
                        return true;
                    }
                    break;
                case FRONT :  // front and back plane
                case BACK :
                    if ((isOnRayW (MinX - fTolerance, MaxX + fTolerance, clVectRes.x) &&
                         isOnRayW (MinY - fTolerance, MaxY + fTolerance, clVectRes.y))) {
                        return true;
                    }
                    break;
            }
        }
    }

    return false;
}

template <class Precision>
inline bool BoundBox3<Precision>::IsCutPlane (const Vector3<Precision> &rclBase,
                                              const Vector3<Precision> &rclNormal) const
{
    const unsigned short num = 8;
    if (fabs(GetCenter().DistanceToPlane(rclBase, rclNormal)) < CalcDiagonalLength()) {
        Precision fD = CalcPoint(CORNER::TLB).DistanceToPlane(rclBase, rclNormal);
        for (unsigned short i = 1; i < num; i++) {
            if ((CalcPoint(i).DistanceToPlane(rclBase, rclNormal) * fD) <= 0.0F) {
                return true;
            }
        }
    }
    return false;
}

// NOLINTBEGIN(bugprone-easily-swappable-parameters)
template <class Precision>
inline bool BoundBox3<Precision>::IntersectWithLine (const Vector3<Precision> & rcBase,
                                                     const Vector3<Precision>& rcDir,
                                                     Vector3<Precision>& rcP0,
                                                     Vector3<Precision>& rcP1) const
// NOLINTEND(bugprone-easily-swappable-parameters)
{
    const unsigned short num = 6;
    Vector3<Precision> clVectRes;
    std::array<Vector3<Precision>, num> clVect;
    unsigned short numIntersect = 0;

    auto checkIntersect = [&](Base::Vector3<Precision> p1,
                              Base::Vector3<Precision> p2) {
        if (isOnRayS(p1.x, p1.y, p1.z) && isOnRayS(p2.x, p2.y, p2.z)) {
            clVect[numIntersect] = clVectRes;
            numIntersect++;
        }
    };

    // cut each face with the line
    for (unsigned short i = 0; i < num; i++) {
        if (IntersectPlaneWithLine(i, rcBase, rcDir, clVectRes)) {
            // check if intersection point is inside
            switch (i) {
            case LEFT :  // left and right plane
            case RIGHT :
                checkIntersect(Vector3<Precision>{MinY, MaxY, clVectRes.y},
                               Vector3<Precision>{MinZ, MaxZ, clVectRes.z});
                break;
            case TOP :  // top and bottom plane
            case BOTTOM :
                checkIntersect(Vector3<Precision>{MinX, MaxX, clVectRes.x},
                               Vector3<Precision>{MinZ, MaxZ, clVectRes.z});
                break;
            case FRONT :  // front and back plane
            case BACK :
                checkIntersect(Vector3<Precision>{MinX, MaxX, clVectRes.x},
                               Vector3<Precision>{MinY, MaxY, clVectRes.y});
                break;
            }
        }
    }

    if (numIntersect == 2) {
        rcP0 = clVect[0];
        rcP1 = clVect[1];
        return true;
    }

    if (numIntersect > 2) { // search two different intersection points
        for (unsigned short i = 1; i < numIntersect; i++) {
            if (clVect[i] != clVect[0]) {
                rcP0 = clVect[0];
                rcP1 = clVect[i];
                return true;
            }
        }
    }

    return false;
}

// NOLINTBEGIN(bugprone-easily-swappable-parameters)
template <class Precision>
inline bool BoundBox3<Precision>::IntersectPlaneWithLine (unsigned short usSide,
                                                          const Vector3<Precision>& rcBase,
                                                          const Vector3<Precision>& rcDir,
                                                          Vector3<Precision>& rcP0) const
// NOLINTEND(bugprone-easily-swappable-parameters)
{
    Precision value;
    Vector3<Precision> cBase;
    Vector3<Precision> cNormal;
    Vector3<Precision>  cDir(rcDir);
    CalcPlane(usSide, cBase, cNormal);

    if ((cNormal * cDir) == 0.0F) {
        return false;  // no point of intersection
    }

    value = (cNormal * (cBase - rcBase)) / (cNormal * cDir);
    cDir.Scale(value, value, value);
    rcP0 = rcBase + cDir;
    return true;
}

template <class Precision>
inline typename BoundBox3<Precision>::SIDE
BoundBox3<Precision>::GetSideFromRay (const Vector3<Precision> &rclPt,
                                      const Vector3<Precision> &rclDir) const
{
    Vector3<Precision> cIntersection;
    return GetSideFromRay( rclPt, rclDir, cIntersection);
}

template <class Precision>
inline typename BoundBox3<Precision>::SIDE
BoundBox3<Precision>::GetSideFromRay (const Vector3<Precision> &rclPt,
                                      const Vector3<Precision> &rclDir,
                                      Vector3<Precision>& rcInt) const
{
    Vector3<Precision> cP0;
    Vector3<Precision> cP1;
    if (!IntersectWithLine(rclPt, rclDir, cP0, cP1)) {
        return INVALID;
    }

    Vector3<Precision>  cOut;
    // same orientation
    if ((cP1-cP0)*rclDir > 0) {
        cOut = cP1;
    }
    else {
        cOut = cP0;
    }

    rcInt = cOut;

    Precision fMax = 1.0e-3F; //NOLINT
    SIDE  tSide = INVALID;

    if (fabs(cOut.x - MinX) < fMax) { // left plane
        fMax = Precision(fabs(cOut.x - MinX));
        tSide = LEFT;
    }

    if (fabs(cOut.x - MaxX) < fMax) { // right plane
        fMax = Precision(fabs(cOut.x - MaxX));
        tSide = RIGHT;
    }

    if (fabs(cOut.y - MinY) < fMax) { // bottom plane
        fMax = Precision(fabs(cOut.y - MinY));
        tSide = BOTTOM;
    }

    if (fabs(cOut.y - MaxY) < fMax) { // top plane
        fMax = Precision(fabs(cOut.y - MaxY));
        tSide = TOP;
    }

    if (fabs(cOut.z - MinZ) < fMax) { // front plane
        fMax = Precision(fabs(cOut.z - MinZ));
        tSide = FRONT;
    }

    if (fabs(cOut.z - MaxZ) < fMax) { // back plane
        fMax = Precision(fabs(cOut.z - MaxZ));
        tSide = BACK;
    }

    return tSide;
}

template <class Precision>
inline Vector3<Precision> BoundBox3<Precision>::ClosestPoint (const Vector3<Precision> &rclPt) const
{
    Vector3<Precision> closest = rclPt;

    Vector3<Precision> center = GetCenter();
    Precision devx = closest.x - center.x;
    Precision devy = closest.y - center.y;
    Precision devz = closest.z - center.z;

    Precision halfwidth  = (MaxX - MinX) / 2;
    Precision halfheight = (MaxY - MinY) / 2;
    Precision halfdepth  = (MaxZ - MinZ) / 2;

    // Move point to be on the nearest plane of the box.
    if ((fabs(devx) > fabs(devy)) && (fabs(devx) > fabs(devz))) {
        closest.x = center.x + halfwidth * ((devx < 0.0) ? -1.0 : 1.0);
    }
    else if (fabs(devy) > fabs(devz)) {
        closest.y = center.y + halfheight * ((devy < 0.0) ? -1.0 : 1.0);
    }
    else {
        closest.z = center.z + halfdepth * ((devz < 0.0) ? -1.0 : 1.0);
    }

    // Clamp to be inside box.
    closest.x = std::min<Precision>(std::max<Precision>(closest.x, MinX), MaxX);
    closest.y = std::min<Precision>(std::max<Precision>(closest.y, MinY), MaxY);
    closest.z = std::min<Precision>(std::max<Precision>(closest.z, MinZ), MaxZ);

    return closest;
}

template <class Precision>
inline BoundBox2d BoundBox3<Precision>::ProjectBox(const ViewProjMethod* proj) const
{
    const int num = 8;
    BoundBox2d  clBB2D;
    clBB2D.SetVoid();

    for (int i = 0; i < num; i++) {
        Vector3<Precision> clTrsPt = (*proj)(CalcPoint(i));
        clBB2D.Add(Vector2d(clTrsPt.x, clTrsPt.y));
    }

    return clBB2D;
}

template <class Precision>
inline BoundBox3<Precision> BoundBox3<Precision>::Transformed(const Matrix4D& mat) const
{
    const int num = 8;
    BoundBox3<Precision> bbox;
    for (int i = 0; i < num; i++) {
        bbox.Add(mat * CalcPoint(i));
    }
    return bbox;
}

template <class Precision>
inline Vector3<Precision> BoundBox3<Precision>::GetCenter () const
{
    return Vector3<Precision>((MaxX + MinX) / 2,
                               (MaxY + MinY) / 2,
                               (MaxZ + MinZ) / 2);
}

template <class Precision>
inline Vector3<Precision> BoundBox3<Precision>::GetMinimum () const
{
    return Vector3<Precision>(MinX, MinY, MinZ);
}

template <class Precision>
inline Vector3<Precision> BoundBox3<Precision>::GetMaximum () const
{
    return Vector3<Precision>(MaxX, MaxY, MaxZ);
}

template <class Precision>
inline Precision BoundBox3<Precision>::CalcDiagonalLength () const
{
    return static_cast<Precision>(sqrt (((MaxX - MinX) * (MaxX - MinX)) +
                                        ((MaxY - MinY) * (MaxY - MinY)) +
                                        ((MaxZ - MinZ) * (MaxZ - MinZ))));
}

template <class Precision>
inline void BoundBox3<Precision>::SetVoid ()
{
    MinX = MinY = MinZ =  std::numeric_limits<Precision>::max();
    MaxX = MaxY = MaxZ = -std::numeric_limits<Precision>::max();
}

template <class Precision>
inline void BoundBox3<Precision>::Enlarge (Precision fLen)
{
    MinX -= fLen; MinY -= fLen; MinZ -= fLen;
    MaxX += fLen; MaxY += fLen; MaxZ += fLen;
}

template <class Precision>
inline void BoundBox3<Precision>::Shrink (Precision fLen)
{
    MinX += fLen; MinY += fLen; MinZ += fLen;
    MaxX -= fLen; MaxY -= fLen; MaxZ -= fLen;
}

template <class Precision>
inline Precision BoundBox3<Precision>::LengthX () const
{
    return MaxX - MinX;
}

template <class Precision>
inline Precision BoundBox3<Precision>::LengthY () const
{
    return MaxY - MinY;
}

template <class Precision>
inline Precision BoundBox3<Precision>::LengthZ () const
{
    return MaxZ - MinZ;
}

template <class Precision>
inline Precision BoundBox3<Precision>::Volume () const
{
    if (!IsValid()) {
        return -1.0;
    }
    return LengthX() * LengthY() * LengthZ();
}

template <class Precision>
inline void BoundBox3<Precision>::MoveX (Precision value)
{
    MinX += value;
    MaxX += value;
}

template <class Precision>
inline void BoundBox3<Precision>::MoveY (Precision value)
{
    MinY += value;
    MaxY += value;
}

template <class Precision>
inline void BoundBox3<Precision>::MoveZ (Precision value)
{
    MinZ += value;
    MaxZ += value;
}

template <class Precision>
inline void BoundBox3<Precision>::ScaleX (Precision value)
{
    MinX *= value;
    MaxX *= value;
}

template <class Precision>
inline void BoundBox3<Precision>::ScaleY (Precision value)
{
    MinY *= value;
    MaxY *= value;
}

template <class Precision>
inline void BoundBox3<Precision>::ScaleZ (Precision value)
{
    MinZ *= value;
    MaxZ *= value;
}

using BoundBox3f = BoundBox3<float>;
using BoundBox3d = BoundBox3<double>;

} // namespace Base

#endif  // BASE_BOUNDBOX_H