import cv2

import imutils

import numpy as np

from math import sqrt

def abs (n):

  if n >= 0:

    return n

  return abs((-1 * n))

class CvImage:

  def __init__ (self, image, name):

    self.__name = name

    self.__originalImage = image

    self.__image = image

    self.__contours = False

    self.__contoursFeatures = False

  def getName (self):

    return self.__name

  def getOriginalImage (self):

    return self.__originalImage

  def getImage (self):

    return self.__image

  def drawCircle (self, center, radious = 1, color = (0, 255, 0), thickness = 2):

    cv2.circle(self.__image, center, radious, color, thickness)

  def drawContours (self, contours, color = (0, 255, 0), thickness = 2):

    cv2.drawContours(self.__image, contours, -1, color, thickness)

  def __show (self, name, image):

    cv2.imshow(name, image)

    cv2.waitKey(0)

  def showOriginal (self):

    self.__show(self.__name + "-original", self.getOriginalImage())

  def show (self):

    self.__show(self.__name, self.__image)

  def morphOperations (self, kernelSize = 3):

    # Open and close morph operations

    kernel = np.ones((kernelSize, kernelSize),np.uint8)

    self.__image = cv2.morphologyEx(self.__image, cv2.MORPH_OPEN, kernel)

    self.__image = cv2.morphologyEx(self.__image, cv2.MORPH_CLOSE, kernel)  

  def hsvFilter (self, lowerHSV, higherHSV):

    # Convert to HSV

    self.__image = cv2.cvtColor(self.__image, cv2.COLOR_BGR2HSV)

    # InRange filter

    self.__image = cv2.inRange(self.__image, lowerHSV, higherHSV)

  def getContours(self):

    if self.__contours == False:

      self.__contours = self.__findCountours()

    return self.__contours

  def getContoursFeatures(self, n = 5):

    if self.__contoursFeatures == False:

      self.__contoursFeatures = self.__findContoursFeatures(n)

    return self.__contoursFeatures

  def gray2bgr (self):

    self.__image = cv2.cvtColor(self.__image, cv2.COLOR_GRAY2BGR)

  def bgr2gray (self):

    self.__image = cv2.cvtColor(self.__image, cv2.COLOR_BGR2GRAY)

  def __findCountours(self):

    # ConvertToGrayScale and filter

    gray = cv2.bilateralFilter(self.__image, 11, 17, 17)

    # Edge algoritm

    edged = cv2.Canny(gray, 30, 200)

    cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    cnts = imutils.grab_contours(cnts)

    # Sort by larger areas

    cnts = sorted(cnts, key = cv2.contourArea, reverse = True)

    return cnts

  def __findContoursFeatures (self, minArea):

    contoursFeatures = []

    cnts = self.getContours()

    for i in range(0, len(cnts)):

      if cv2.contourArea(cnts[i]) >= minArea:

        # Compute the center of the contour

        M = cv2.moments(cnts[i])

        cx = int(M["m10"] / M["m00"])

        cy = int(M["m01"] / M["m00"])

        # Get some basic features

        perimeter = cv2.arcLength(cnts[i], True)

        epsilon = 0.1*perimeter

        approx = cv2.approxPolyDP(cnts[i],epsilon,True)

        # Calculate eccentricity

        (x, y), (MA, ma), angle = cv2.fitEllipse(cnts[i])

        a = ma/2

        b = MA/2

        if (a > b):

          eccentricity = sqrt(pow(a, 2)-pow(b, 2))

          eccentricity = round(eccentricity/a, 2)

        else:

          eccentricity = sqrt(pow(b, 2)-pow(a, 2))

          eccentricity = round(eccentricity/b, 2)

        # Append features

        contoursFeatures.append({

          "area": cv2.contourArea(cnts[i]),

          "perimeter": perimeter,

          "eccentricity": eccentricity,

          "centroid": (cx, cy),

          "approxDp": np.squeeze(approx),

          "convexHull": np.squeeze(cv2.convexHull(cnts[i]))

        })

      else:

        break

    return contoursFeatures