Saf/Math/Algebra/Hyperplane.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published 
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Saf 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_MATH_ALGEBRA_HYPERPLANE_H
#define SAF_MATH_ALGEBRA_HYPERPLANE_H

#include "Vector.h"

namespace Saf
{
    namespace Math
    {
        namespace Algebra
        {
            template <Size N, class T>
            class Hyperplane
            {
            private:
                Vector<N,T> m_normal;
                T m_d;

            public:
                Hyperplane()                        
                {}

                Hyperplane(const Vector<N,T> &normal, const Vector<N,T> &point)
                {
                    Set(normal, point);
                }

                Hyperplane(const Hyperplane<N,T> &p)
                {
                    *this = p;
                }

                void Set(const Vector<N,T> &normal, const Vector<N,T> &point)
                {
                    m_normal = normal.Normalized();
                    m_d = m_normal.DotProduct(point);
                }

                const Vector<N,T> &Normal() const
                {
                    return m_normal;
                }

                T Distance() const
                {
                    return m_d;
                }

                bool IsAbove (const Vector<N,T> &point) const
                {
                    return m_normal.DotProduct(point) > m_d;
                }

                Hyperplane<N,T>& operator= (const Hyperplane<N,T> &p)
                {
                    m_normal = p.m_normal;
                    m_d = p.m_d;
                    return *this;
                }
            };
        }
    }
}

#endif