Cell.h

// Cell class
// Written by Sergey G. Kosov in 2013 for Project X
#pragma once

#include "types.h"

const double MIN_RADIUS = 1.0;      

namespace HexagonCells
{
    typedef struct {
        double  R;      
        double  r;      
        double  S;      
        int     N;      
    } cell_params;

    enum cell_int_app {
        CELL_AVG,       
        CELL_MV         
    };


    // ================================ Cell Class ================================
    class CCell
    {
        friend class CMarker;

    public:
        DllExport CCell(void);
        DllExport CCell(CvSize imgSize, cell_int_app cellIntApp = CELL_AVG);
        DllExport CCell(Mat &img, cell_int_app cellIntApp = CELL_AVG);
        DllExport CCell(double R);
        DllExport CCell(CvSize imgSize, double R, cell_int_app cellIntApp = CELL_AVG);
        DllExport CCell(Mat &img, double R, cell_int_app cellIntApp = CELL_AVG);
        DllExport ~CCell(void);

        DllExport void            clear(void);
        DllExport void            setImage(Mat &img);
        DllExport void            setRadius(double R);
        DllExport void            setInterpolationApproach(cell_int_app cellIntApp);

        DllExport cell_params     getInfo(void);
        DllExport int             getIDX(int x, int y);
        DllExport int             getNeighbourIDX(int idx, int i);
        DllExport int           * getNeighbourhood(int idx);
        DllExport CvScalar        getVal(int idx);

        // Brute - force functions
        DllExport Mat             getLUT(void) { return m_LUT; }
        DllExport void            setLUT(Mat &LUT) { LUT.copyTo(m_LUT); }


    private:
        int calculate_LUT(void);        // 0 on success, error_code otherwise
        int calculate_nCells(void);     // 0 on success, error_code otherwise
        int calculate_cellData(void);   // 0 on success, error_code otherwise

        bool                  ifInsideCell(CvPoint2D64f x, CvPoint2D64f C) const;
        static CvPoint2D64f   getBoundaryPoint(CvPoint2D64f C, int i, double R);


        // Coordinate translation functions (idx <-> h <-> d)
        static Point          idx2h(int idx, double R, CvSize imgSize);         // index to hexagonal
        inline int            h2idx(Point c) const;         // hexagonal to index
        static CvPoint2D64f   idx2d(int idx, double R, CvSize imgSize);         // index to cartesian
        inline int            d2idx(CvPoint2D64f C);                            // cartesian to index
    //  static CvPoint2D64f   h2d(Point c);
        inline Point          d2h(CvPoint2D64f C) const;                        // cartesian to hexagonal


    private:
        Mat             m_img;          // Mat();           // The image
        CvSize          m_imgSize;      // cvSize(0, 0);    // 
        Mat             m_LUT;          // Mat();           // Look-up table Mat(m_imgSize, CV_32SC1)
        double          m_R;            // -1;              // Hexagon outer radius
        double          m_r;            // -1;              // Hexagon inner radius
        int             m_nCells;       // -1;              // Number of of hexagons in the image
        cell_int_app    m_cellIntApp;   // CELL_AVG;        // Cell interpolation approach
        Mat             m_cellData;     // Mat();           // Direct cell datas



        // Copy semantics are disabled
        CCell(const CCell &rhs) {}
        const CCell & operator= (const CCell & rhs) { return *this; }
    };

}