cPolygon.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPolygon_H
#define _INC_cPolygon_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cRectI.h"
#include "GrayCore/include/cArray.h"
 
namespace GrayLib
{
        template < typename TYPE, class TYPE_RECT = cRectNT<TYPE> >
        class GRAYLIB_LINK cPolygonT
        {
 
                typedef cPolygonT<TYPE, TYPE_RECT> THIS_t;
 
        public:
                typedef TYPE DVALUE_t;          
                typedef cVecT2<TYPE> POINT_t;
                typedef TYPE_RECT RECT_t;       
 
                static const ITERATE_t k_MAX_VERTS = 1024; 
 
        protected:
                TYPE_RECT m_rectUnion;  
                cArrayStruct<POINT_t> m_aPoints;        
 
        public:
                cPolygonT()
                {
                        m_rectUnion.SetRectEmptyX();
                }
 
                const TYPE_RECT& get_BoundingRect(void) const
                {
                        return m_rectUnion;
                }
                ITERATE_t get_NumVerts() const
                {
                        return m_aPoints.GetSize();
                }
                bool isPolyEmpty() const
                {
                        return(m_aPoints.GetSize() <= 0);
                }
                const POINT_t& GetVert(ITERATE_t i) const
                {
                        return m_aPoints.ConstElementAt(i);
                }
                POINT_t& RefVert(ITERATE_t i)
                {
                        return m_aPoints.ElementAt(i);
                }
 
                bool IsEqual(const THIS_t& p) const
                {
                        if (!m_rectUnion.IsEqual(p.m_rectUnion))
                                return false;
                        if (get_NumVerts() != p.get_NumVerts())
                                return false;
                        return true;
                }
 
                ITERATE_t CreatePolygonPoints(const POINT_t* pPoints, ITERATE_t nCount)
                {
                        SetEmpty();
                        if (nCount <= 0 || nCount > k_MAX_VERTS)        // invalid.
                                return 0;
                        m_aPoints.SetSize(nCount);
                        if (pPoints != nullptr)
                        {
                                for (ITERATE_t i = 0; i < nCount; i++)
                                {
                                        m_aPoints.SetAt(i, pPoints[i]);
                                        m_rectUnion.UnionPoint(pPoints[i].x, pPoints[i].y);
                                }
                        }
                        return nCount;
                }
 
                void SetEmpty()
                {
                        m_rectUnion.SetRectEmptyX();
                        m_aPoints.RemoveAll();
                }
                void DeleteVert(ITERATE_t i)
                {
                        m_aPoints.RemoveAt(i);
                }
                void InsertVert(ITERATE_t i, const POINT_t& pt)
                {
                        m_rectUnion.UnionPoint(pt.x, pt.y);
                        m_aPoints.InsertAt(i, pt);
                }
                ITERATE_t AddVert(const POINT_t& pt)
                {
                        m_rectUnion.UnionPoint(pt.x, pt.y);
                        return m_aPoints.Add(pt);
                }
                ITERATE_t AddVert(TYPE x, TYPE y)
                {
                        return AddVert(POINT_t(x, y));
                }
 
                void UnionPolyRect(TYPE_RECT& rect) const
                {
                        ITERATE_t nPoints = m_aPoints.GetSize();
                        for (ITERATE_t i = 0; i < nPoints; i++)
                        {
                                rect.UnionPoint(m_aPoints[i].x, m_aPoints[i].y);
                        }
                }
 
                void SetCopy(const THIS_t& poly)
                {
                        m_rectUnion = poly.m_rectUnion;
                        m_aPoints.SetCopy(poly.m_aPoints);
                }
 
                void put_PolyRect(const TYPE_RECT& rect)
                {
                        m_rectUnion = rect;
                        m_aPoints.SetSize(4);
                        m_aPoints.SetAt(0, POINT_t(rect.left, rect.top));
                        m_aPoints.SetAt(1, POINT_t(rect.right, rect.top));
                        m_aPoints.SetAt(2, POINT_t(rect.right, rect.bottom));
                        m_aPoints.SetAt(3, POINT_t(rect.left, rect.bottom));
                }
                void put_PolyRect(TYPE fSizeX, TYPE fSizeY)
                {
                        put_PolyRect(TYPE_RECT(0, 0, fSizeX, fSizeY));
                }
 
                void OffsetPoly(TYPE dx, TYPE dy)
                {
                        ITERATE_t nPoints = m_aPoints.GetSize();
                        for (ITERATE_t i = 0; i < nPoints; i++)
                        {
                                m_aPoints[i].x += dx;
                                m_aPoints[i].y += dy;
                        }
                        m_rectUnion.OffsetRect(dx, dy);
                }
        };
 
        template < typename TYPE = float, class TYPE_RECT = cRectFT<TYPE> >
        class GRAYLIB_LINK cPolygonFT : public cPolygonT<TYPE, TYPE_RECT>
        {
 
        public:
                typedef cPolygonT<TYPE, TYPE_RECT> SUPER_t;
                typedef typename SUPER_t::DVALUE_t DVALUE_t;            // __GNUC__ needs this.
                typedef typename SUPER_t::POINT_t POINT_t;
                typedef typename SUPER_t::RECT_t RECT_t; // ;
 
        public:
                cPolygonFT()
                {
                }
                ~cPolygonFT()
                {
                }
 
                ITERATE_t _cdecl CreatePolygonValuesF(ITERATE_t nCount, /* DVALUE_t x1, DVALUE_t y1, DVALUE_t x2, DVALUE_t y2, DVALUE_t x3, DVALUE_t y3, */ ...);
                bool FixPolygon();
 
                bool PtInPoly(DVALUE_t x, DVALUE_t y) const;
                bool PtInPoly(const POINT_t& pt) const
                {
                        return PtInPoly(pt.x, pt.y);
                }
 
                HRESULT v_SetPoly(const cVariant& vVal, ITERATE_t iStart = 0);
                void v_GetPoly(cVariant& vVal) const;
 
                bool IsRectIntersect(const RECT_t& rect) const;
 
                cString toString(void) const;
 
                ITERATE_t FindClosestVert(const POINT_t& pt) const;
        };
 
        class GRAYLIB_LINK cPolygon : public cPolygonT<int, cRectI>
        {
 
        public:
                cPolygon();
                ~cPolygon();
 
                ITERATE_t _cdecl CreatePolygonValuesF(ITERATE_t nCount, /* DVALUE_t x1, DVALUE_t y1, DVALUE_t x2, DVALUE_t y2, DVALUE_t x3, DVALUE_t y3, */ ...);
 
                bool PtInPoly(DVALUE_t x, DVALUE_t y) const;
                bool PtInPoly(const POINT_t& pt) const
                {
                        return PtInPoly(pt.x, pt.y);
                }
        };
 
        typedef cPolygonFT<float, cRectf> cPolygonf;
        typedef cPolygonFT<double, cRectd> cPolygond;
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYLIB_LINK cPolygonT<int, cRectI>;
        template class GRAYLIB_LINK cPolygonT<float, cRectf>;
        template class GRAYLIB_LINK cPolygonT<double, cRectd>;
#endif
 
}
 
#endif // _INC_cPolygon_H