RectPrism.h

 
#pragma once
#include "ConvexObj.h"
#include "Rotation.h"
 
namespace CommonMath
{


    class RectPrism : public ConvexObj
    {
    public:

        RectPrism(Vec3 center, Vec3 sideLengths) : _centerPoint(center), _sideLengths(sideLengths)
        {
            // Side lengths must be positive
            assert(sideLengths.x > 0 && sideLengths.y > 0 && sideLengths.z > 0);
        }


        Boundary GetTangentPlane(Vec3 const testPoint)
        {
            // Write testPoint in the local coordinate frame
            Vec3 p = testPoint - _centerPoint;
 
            // Compute Euclidean projection onto cube
            Boundary bound;
            for (int i = 0; i < 3; i++)
            {
                if (p[i] < -_sideLengths[i] / 2)
                {
                    bound.point[i] = -_sideLengths[i] / 2;
                }
                else if (p[i] > _sideLengths[i] / 2)
                {
                    bound.point[i] = _sideLengths[i] / 2;
                }
                else
                {
                    bound.point[i] = p[i];
                }
            }
 
            // Convert point back to global coordinates and get unit normal
            bound.point = bound.point + _centerPoint;
            bound.normal = (testPoint - bound.point).GetUnitVector();
            return bound;
        }


        bool IsPointInside(Vec3 const testPoint)
        {
            // Write testPoint in the local coordinate frame
            Vec3 p = testPoint - _centerPoint;
 
            // Check if testPoint is inside the rectangular prism
            return (fabs(p.x) <= _sideLengths.x / 2) && (fabs(p.y) <= _sideLengths.y / 2) &&
                   (fabs(p.z) <= _sideLengths.z / 2);
        }
 
        Vec3 GetRandomPositionInside(std::default_random_engine randomGen)
        {
            std::uniform_real_distribution<double> posX(-_sideLengths.x / 2, _sideLengths.x / 2);
            std::uniform_real_distribution<double> posY(-_sideLengths.y / 2, _sideLengths.y / 2);
            std::uniform_real_distribution<double> posZ(-_sideLengths.z / 2, _sideLengths.z / 2);
 
            Vec3 randomPos = Vec3(posX(randomGen), posY(randomGen), posZ(randomGen));
            return _centerPoint + randomPos;
        }

        void SetCenterPoint(Vec3 center)
        {
            _centerPoint = center;
        }

        void SetSideLengths(Vec3 sideLen)
        {
            _sideLengths = sideLen;
        }
 
    private:
        Vec3 _centerPoint;  
        Vec3 _sideLengths;  
    };
 
}  // namespace CommonMath