import cv2
import sys
import numpy as np
import pprint

np.set_printoptions(precision=3, threshold=np.inf, linewidth=np.inf, suppress=True)

def mode_filter(roi):
    values = np.zeros((1, 256), dtype="uint8")

    for pos, val in np.ndenumerate(roi):
        values[0, val] += 1

    print(values)
    return int(np.argmax(values[0]))

class Gridder:

    def __init__(self):
        self.cell_map = {}

    def get_roi(self, src, pt1, pt2):

        col1, col2 = (pt1[0], pt2[0]) if pt1[0] < pt2[0] else (pt2[0], pt1[0])
        row1, row2 = (pt1[1], pt2[1]) if pt1[1] < pt2[1] else (pt2[1], pt1[1])
        return src[row1:row2, col1:col2]

    def calc_roi_descriptor(self, roi):

        # mean, std_dev = cv2.meanStdDev(roi)
        # return [mean[0][0], std_dev[0][0]]
        return mode_filter(roi)

    def grid_img(self, src, nCols=7, nRows=7):

        gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
        cells = np.zeros(gray.shape, dtype="uint8")
        display_img = src
        cell_w = int(gray.shape[1] / nCols)
        cell_h = int(gray.shape[0] / nRows)

        for c in range(nCols):
            cv2.line(display_img, (c*cell_w, 0), (c*cell_w, display_img.shape[0]), (0,255,0), 1)
            cv2.line(display_img, (0, c*cell_h), (display_img.shape[1], c*cell_h), (0,255,0), 1)

            for r in range(nRows):
                roi = self.get_roi(gray, (c*cell_w, r*cell_h), ((c+1)*cell_w, (r+1)*cell_h))

                self.cell_map[ (c,r) ] = self.calc_roi_descriptor(roi)
                cv2.rectangle(cells, (c*cell_w, r*cell_h), ((c+1)*cell_w, (r+1)*cell_h), (self.cell_map[ (c,r) ],), -1)

                cv2.imshow('roi', roi)
                cv2.imshow('cells', cells)
                cv2.imshow('src', src)
                print('{}, {}'.format((c,r), self.cell_map[ (c,r) ]))
                cv2.waitKey(0)

        return [gray, display_img, cells]

    def connected_component_labelling(display_img, gray, nCols=7, nRows=7):

        label_index = 1

        for c in range(nCols):
            for r in range(nRows):

                cur = self.cell_map[ (c,r) ]
                left = self.cell_map[ (c-1, r) ]
                top = self.cell_map[ (c, r-1) ]

                left_lbl = sys.maxint
                top_lbl = sys.maxint
                if left and len(left) > 2:
                    left_lbl = left[2]
                if top and len(top) > 2:
                    top_lbl = top[2]

                lbl = left_lbl if left_lbl < top_lbl else top_lbl

                if (lbl >= sys.maxint):
                    lbl = label_index
                    label_index += 1

                cur.append(lbl)

def main():

    src = cv2.imread('../images/blob2.png')
    print(src.shape)

    gridder = Gridder()
    gray, display_img, cells = gridder.grid_img(src)

    pp = pprint.PrettyPrinter(indent=2)
    pp.pprint(gridder.cell_map)

    cv2.imshow('display_img', display_img)
    cv2.imshow('gray', gray)
    cv2.imshow('cells', cells)
    cv2.waitKey(0)

main()