Point2D.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   Point2D.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2008-09-25
//  Copyright (C) MicroStrategy Incorporated 2008
//  All Rights Reserved
//==============================================================================================

#ifndef MsiChart_Point2D_h
#define MsiChart_Point2D_h

#include "PDCHeader/PDCvector"
#include "PDCHeader/PDCcmath"

#ifdef _VE_CE
#pragma warning(disable : 4244)
#pragma warning(disable : 4305)
#endif

namespace MsiChart
{
    template <typename T = double>
    class Point
    {
    public:
        Point(T iX = T(), T iY = T()): x(iX), y(iY){}
        Point(const Point<T>& irPoint):x(irPoint.x), y(irPoint.y){}
        template <typename U>
        Point(const Point<U>& irPoint);

        void Reset(T iX, T iY);

        double DistanceSquared(const Point<T>& irPoint) const;
        double Distance(const Point<T>& irPoint) const;

        bool IsInPolygon(const std::vector<Point<T> >& irPolygon) const;
        
        bool IsStrictlyInPolygon(const std::vector<Point<T> >& irPolygon) const;
        bool operator != (const Point<T>& irPoint) const;
        bool operator == (const Point<T>& irPoint) const;
        Point<T> operator - () const;

        void Rotate(const Point<T>& irAnchor, double iRadian);

        Point<T> RotateAndClone(const Point<T>& irAnchor, double iRadian);

        Point<T> MiddleTo(const Point<T>& irPoint) const;

        Point<T> Shifted(const Point<T>& irOffset) const;

        void Swap();

        void Swap(Point<T>& iorPoint);

        bool IsOnSegment(const Point<T>& irSegmentStart, const Point<T>& irSegmentEnd, bool iExclude) const;

        bool IsOnVerOrHorSegment(const Point<T>& irSegmentStart, const Point<T>& irSegmentEnd) const;

#ifndef _VE_CE

        CGPoint GetCGPoint() const;
#endif
        
        double DistanceToPolygon(const std::vector<Point<T> >& irPolygon) const;
        
        double DistanceToLine(const Point<T>& irLineStart, const Point<T>& irLineEnd) const;


        T x;    
        T y;    
    };


    template<typename T>
    template<typename U> Point<T>::Point(const Point<U>& iPoint)
    {
        x = static_cast<T>(iPoint.x);
        y = static_cast<T>(iPoint.y);
    }

    template<typename T>
    inline void Point<T>::Reset(T iX, T iY)
    {
        x = iX;
        y = iY;
    }

    template<typename T>
    double Point<T>::DistanceSquared(const Point<T>& irPoint) const
    {
        return (x - irPoint.x) * (x - irPoint.x)
            + (y - irPoint.y) * (y - irPoint.y);
    }

    template<typename T>
    double Point<T>::Distance(const Point<T>& irPoint) const
    {
        return std::sqrt(DistanceSquared(irPoint));
    }

    template<typename T>
    bool Point<T>::operator != (const Point<T>& irPoint) const
    {
        return ((x != irPoint.x) || (y != irPoint.y));
    }
    
    template<typename T>
    bool Point<T>::operator == (const Point<T>& irPoint) const
    {
        return ((x == irPoint.x) && (y == irPoint.y));
    }

    template<typename T>
    Point<T> Point<T>::operator - () const
    {
        return Point<T>(-x, -y);
    }

    //  Reference: http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/
    template<typename T>
    bool Point<T>::IsInPolygon(const std::vector<Point<T> >& irPolygon) const
    {
        unsigned Int32 lNumberOfEdges = (Int32)irPolygon.size();
        if (lNumberOfEdges < 3) // A polygon should have at least 3 edges.
            return false;

        //[consider to do] Li en: special case, across at the end point of the edge.
        bool lResult = false;
        for (unsigned Int32 i = 0, j = lNumberOfEdges - 1; i < lNumberOfEdges; j = i++)
        {
            if (((irPolygon[i].y <= y && y < irPolygon[j].y) ||
                (irPolygon[j].y <= y && y < irPolygon[i].y)) &&
                x <= (irPolygon[j].x - irPolygon[i].x) * (y - irPolygon[i].y) * 1.0 / (irPolygon[j].y - irPolygon[i].y) + irPolygon[i].x)
            {
                lResult = !lResult;
            }
        }
        return lResult;
    }

    template<typename T>
    bool Point<T>::IsStrictlyInPolygon(const std::vector<Point<T> >& irPolygon) const
    {       
        if (!Point<T>(x + 0.1f, y).IsInPolygon(irPolygon))
            return false;
        if (!Point<T>(x - 0.1f, y).IsInPolygon(irPolygon))
            return false;
        if (!Point<T>(x, y + 0.1f).IsInPolygon(irPolygon))
            return false;
        if (!Point<T>(x, y - 0.1f).IsInPolygon(irPolygon))
            return false;
        return true;        
    }

    template<typename T>
    void Point<T>::Rotate(const Point<T>& irAnchor, double iRadian)
    {
        double lXDist = x - irAnchor.x;
        double lYDist = y - irAnchor.y;

        x = static_cast<T>(irAnchor.x + cos(iRadian) * lXDist - sin(iRadian) * lYDist);
        y = static_cast<T>(irAnchor.y + sin(iRadian) * lXDist + cos(iRadian) * lYDist);
    }

    template<typename T>
    Point<T> Point<T>::RotateAndClone(const Point<T>& irAnchor, double iRadian)
    {
        Rotate(irAnchor, iRadian);
        return *this;
    }

    // specialize for Int32
    template<>
    void Point<Int32>::Rotate(const Point<Int32>& irAnchor, double iRadian);

    //template<>
    //Point<Int32> Point<Int32>::RotateAndClone(const Point<Int32>& irAnchor, double iRadian);

    template<typename T>
    Point<T> Point<T>::MiddleTo(const Point<T> &irPoint) const
    {
        return Point<T>((x + irPoint.x) / 2, (y + irPoint.y) / 2);
    }

    template<typename T>
    Point<T> Point<T>::Shifted(const Point<T>& irOffset) const
    {
        return Point<T>(x + irOffset.x, y + irOffset.y);
    }

    template<typename T>
    void Point<T>::Swap()
    {
        std::swap(x, y);
    }

    template<typename T>
    void Point<T>::Swap(Point<T>& iorPoint)
    {
        std::swap(x, iorPoint.x);
        std::swap(y, iorPoint.y);
    }

    template<typename T>
    bool Point<T>::IsOnSegment(const Point<T>& iSegmentStart, const Point<T>& iSegmentEnd, bool iExclude) const
    {       
        const float lTolerance = iExclude ? 0.01f : -0.01f;
        if(fabs(iSegmentStart.x - iSegmentEnd.x) < 0.01f)//vertical segment, so compare Y
        {
            if((y - iSegmentStart.y) > lTolerance && (iSegmentEnd.y - y) > lTolerance)
                return true;
            if((y - iSegmentEnd.y) > lTolerance && (iSegmentStart.y - y) > lTolerance)
                return true;
        }
        else//not vertical, so compare X
        {
            if((x - iSegmentStart.x) > lTolerance && (iSegmentEnd.x - x) > lTolerance)
                return true;
            if((x - iSegmentEnd.x) > lTolerance && (iSegmentStart.x - x) > lTolerance)
                return true;
        }
        return false;
    }

    template<typename T>
    bool Point<T>::IsOnVerOrHorSegment(const Point<T>& irSegmentStart, const Point<T>& irSegmentEnd) const
    {
        if (y == irSegmentStart.y && y == irSegmentEnd.y)
        {
            return ((x - irSegmentStart.x) >= 0 && (irSegmentEnd.x - x) >= 0) ||
                ((x - irSegmentStart.x) <= 0 && (irSegmentEnd.x - x) <= 0);
        }

        if (x == irSegmentStart.x && x == irSegmentEnd.x)
        {
            return ((y - irSegmentStart.y) >= 0 && (irSegmentEnd.y - y) >= 0) ||
                ((y - irSegmentStart.y) <= 0 && (irSegmentEnd.y - y) <= 0);
        }
        return false;
    }
    
#ifndef _VE_CE
    template<typename T>
    CGPoint Point<T>::GetCGPoint() const
    {
        return CGPointMake(x, y);
    }
#endif

    template<typename T>
    double Point<T>::DistanceToPolygon(const std::vector<Point<T> >& irPolygon) const
    {
        if (IsInPolygon(irPolygon))
            return 0;
        
        const size_t lNumOfEdges = irPolygon.size();
        double lDistance = DistanceToLine(irPolygon[0], irPolygon[lNumOfEdges - 1]);        
        for (size_t i = 0; i + 1 < lNumOfEdges; ++i)
        {
            double lNewDistance = DistanceToLine(irPolygon[i], irPolygon[i + 1]);
            if (lDistance > lNewDistance)
            {
                lDistance = lNewDistance;
            }
        }
        return lDistance;
    }
    
    template<typename T>
    double Point<T>::DistanceToLine(const Point<T>& irLineStart, const Point<T>& irLineEnd) const
    {
        double lPointToStart2 = DistanceSquared(irLineStart);
        double lPointToEnd2 = DistanceSquared(irLineEnd);
        double lStartToEnd2 = irLineStart.DistanceSquared(irLineEnd);
        
        const float lTolerance = 0.01;
        if (lPointToStart2 < lTolerance || lPointToEnd2 < lTolerance)
            return 0;
        if (lStartToEnd2 < lTolerance)
            return std::sqrt(lPointToStart2);
        
        if (lPointToStart2 >= lPointToEnd2 + lStartToEnd2)
            return std::sqrt(lPointToEnd2);
        
        if (lPointToEnd2 >= lPointToStart2 + lStartToEnd2)
            return std::sqrt(lPointToStart2);
        
        Point<T> lStartToPoint(x - irLineStart.x, y - irLineStart.y);
        Point<T> lStartToEnd(irLineEnd.x - irLineStart.x, irLineEnd.y - irLineStart.y);
        double lCrossProduct = lStartToPoint.x * lStartToEnd.y - lStartToPoint.y * lStartToEnd.x;
        return (lCrossProduct < 0 ? -lCrossProduct : lCrossProduct) / std::sqrt(lStartToEnd2);
        
    }


    typedef Point<Int32> Point2D;
    typedef Point<float> FPoint2D;
#ifdef _VE_CE
    typedef Point<double> DPoint2D;
#endif
}

#endif