from math import*
from decimal import Decimal
from numpy import linalg as LA
import numpy as np
import cv2

class Similarity():

    """ Five similarity measures function """

    def euclidean_distance(self,x,y):

        """ return euclidean distance between two lists """

        return sqrt(sum(pow(a-b,2) for a, b in zip(x, y)))

    def manhattan_distance(self,x,y):

        """ return manhattan distance between two lists """

        return sum(abs(a-b) for a,b in zip(x,y))

    def minkowski_distance(self,x,y,p_value):

        """ return minkowski distance between two lists """

        return self.nth_root(sum(pow(abs(a-b),p_value) for a,b in zip(x, y)),
           p_value)

    def nth_root(self,value, n_root):

        """ returns the n_root of an value """

        root_value = 1/float(n_root)
        return round (Decimal(value) ** Decimal(root_value),3)

    def cosine_similarity(self,x,y):

        """ return cosine similarity between two lists """

        numerator = sum(a*b for a,b in zip(x,y))
        denominator = self.square_rooted(x)*self.square_rooted(y)
        return round(numerator/float(denominator),3)

    def square_rooted(self,x):

        """ return 3 rounded square rooted value """

        return round(sqrt(sum([a*a for a in x])),3)

    def jaccard_similarity(self,x,y):
        """ returns the jaccard similarity between two lists """

        intersection_cardinality = len(set.intersection(*[set(x), set(y)]))
        union_cardinality = len(set.union(*[set(x), set(y)]))
        return intersection_cardinality/float(union_cardinality)

def feature_matching_sim(matches):
    similar_regions = [i for i in matches if i.distance <= 1.5]
    return (len(similar_regions)/ len(matches))

def normalize(arr):
    rng = arr.max()-arr.min()
    amin = arr.min()
    return (arr-amin)*255/rng

def distances_p1_p2(p1, p2, vis=False):
    suppress_warnings_and_error_messages = True
    # the main function to create Similarity class instance and get used to it
    measures = Similarity()

    p1 = np.array(p1).flatten()
    p2 = np.array(p2).flatten()
    try:
        max_euclidian = measures.euclidean_distance(np.ones_like(p1) * 255, np.zeros_like(p2))
        max_manhattan = measures.manhattan_distance(np.ones_like(p1) * 255, np.zeros_like(p2))
        max_minkowski = measures.minkowski_distance(np.ones_like(p1) * 255, np.zeros_like(p2), 3)

        # distance ranging from 0 to 1
        euclidian = measures.euclidean_distance(p1, p2) / max_euclidian
        manhattan = measures.manhattan_distance(p1, p2) / max_manhattan
        minkowski = float(measures.minkowski_distance(p1, p2,3)) / float(max_minkowski)
        cosine = min(measures.cosine_similarity(p1, p2), 1.)
        jacard = min(measures.jaccard_similarity(p1, p2), 1.)

    except Exception as e:
        import traceback
        if not suppress_warnings_and_error_messages:
            traceback.print_exc()

    if vis:
        print("Euclidiean distance: {}".format(euclidian))
        print("Manhattan distance: {}".format(manhattan))
        print("Minkowski distance: {}".format(minkowski))
        print("Cosine similarity: {}".format(cosine))
        print("Jacard similarity: {}".format(jacard))

    return euclidian, manhattan, minkowski, cosine, jacard