import cv2
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as img
import glob
import skimage
import skimage.feature as skifeat
import skimage.morphology as skimorp
import skimage.color as skicol
import skimage.io as simg
import skimage.exposure as sexp
import skimage.filters as skifil

def printNoise(origin,filter,name):
    plt.subplot(122); plt.axis("off"); plt.title(name)
    plt.imshow(filter, cmap="gray")
    plt.subplot(121); plt.axis("off"); plt.title("Origin")
    plt.imshow(origin, cmap="gray")
    plt.show()

def add_noise(noise_typ,image):
   if noise_typ == "gauss":
      mean = 0
      sigma = 0.1
      gauss = np.random.normal(mean,sigma,image.shape)
      noisy = image + gauss
      return noisy
   elif noise_typ == "uniform":
      low = 0
      high = 1
      uniform = np.random.uniform(low,high,image.shape)
      noisy = image + uniform
      return noisy
   elif noise_typ == "s&p":
      #row,col,ch = image.shape
      s_vs_p = 0.5
      amount = 0.02
      res = np.copy(image)
      # Salt mode
      num_salt = np.ceil(amount * image.size * s_vs_p)
      coords = [np.random.randint(0, i - 1, int(num_salt))    for i in image.shape]
      res[coords] = 1

      # Pepper mode
      num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))
      coords = [np.random.randint(0, i - 1, int(num_pepper))    for i in image.shape]
      res[coords] = 0
      return res
   elif noise_typ == "poisson":
       lam = 0.1
       poisson = np.random.poisson(lam,image.shape)
       noisy = poisson + image
       return noisy
   elif noise_typ =="speckle":
      row,col = image.shape
      gauss = np.random.randn(row,col)*0.2
      noisy = gauss*image + image
      return noisy
def exOne():
    img = plt.imread("images\\coins.png")
    noise = add_noise("uniform",img)
    printNoise(img,noise,"uniform")

def lowpass_filter(noise_typ,image,sigma=1.0,radius=2,ksize=3,s_0=80,s_1=120):
      if noise_typ == "gauss":
          gray = skicol.rgb2gray(image)
          filter = skifil.gaussian(gray,sigma)
          return filter
      elif noise_typ == "mean":
          gray = skicol.rgb2gray(image)
          filter = skimage.filters.rank.mean(gray, skimorp.disk(radius))
          return filter
      elif noise_typ == "median": #for s&p
          gray = skicol.rgb2gray(image)
          kernel = np.ones((ksize,ksize),dtype=np.uint8)
          filter = skifil.median(gray, kernel)
          return filter
      elif noise_typ == "meanBilateral": #for speckle
          gray = skicol.rgb2gray(image)
          filter = skimage.filters.rank.mean_bilateral(gray, skimorp.disk(radius), s0=s_0, s1=s_1)
          return image - gray
def exTwo():
    img = plt.imread("images\\gaussianNoise.png")
    param = {"sigma":1.0,  "radius":2,  "ksize":3,  "s_0":80,  "s_1":120}
    mode = "mean"
    filter = lowpass_filter(mode,img,radius=param["radius"])
    printNoise(img,filter,mode)

def exThree():
    img1 = plt.imread("images\\coins.png")
    img2 = plt.imread("images\\cameraman.bmp")
    img3 = plt.imread("images\\horse.png")
    gaussian = add_noise("gauss",img1)
    snp = add_noise("s&p", img2)
    uniform = add_noise("uniform", img3)

    filterForGauss = lowpass_filter("gauss",gaussian)
    filterForSnp = lowpass_filter("median",snp)
    filterForUniform = lowpass_filter("gauss",uniform)

    printNoise(img1,gaussian,"gaussian")
    printNoise(gaussian,filterForGauss,"For gaussian")

    printNoise(img2,snp,"snp")
    printNoise(snp,filterForSnp,"For snp")

    printNoise(img3,uniform,"uniform")
    printNoise(uniform,filterForUniform,"For uniform")

    img4 = plt.imread("images\\lena.png")
    poisson = add_noise("poisson", img4)
    printNoise(img4,poisson,"poisson")
    filterForPoisson = poisson.copy()
    kernel = np.ones((3,3),dtype=np.uint8)
    filterForPoisson[:,:,0] = skifil.median(poisson[:,:,0], kernel)
    filterForPoisson[:,:,1] = skifil.median(poisson[:,:,1], kernel)
    filterForPoisson[:,:,2] = skifil.median(poisson[:,:,2], kernel)
    printNoise(poisson,filterForPoisson,"For poisson")

def highpass_filter(noisy_typ,image,kSize=5,Mask=None,Sigma=2,low_thresh=0.1,high_thresh=0.2):
    if noisy_typ == "roberts":
        gray = gray = skicol.rgb2gray(image)
        filter = skimage.filters.roberts(gray,mask=Mask)
        return filter
    elif noisy_typ == "sobel":
        gray = gray = skicol.rgb2gray(image)
        filter = skimage.filters.sobel(gray,mask=Mask)
        return filter
    elif noisy_typ == "scharr":
        gray = gray = skicol.rgb2gray(image)
        filter = skimage.filters.scharr(gray,mask=Mask)
        return filter
    elif noisy_typ == "prewitt":
        gray = gray = skicol.rgb2gray(image)
        filter = skimage.filters.prewitt(gray,mask=Mask)
        return filter
    elif noisy_typ == "laplace":
        gray = gray = skicol.rgb2gray(image)
        filter = skimage.filters.laplace(gray,ksize=kSize)
        return filter
    elif noisy_typ == "canny":
        gray = gray = skicol.rgb2gray(image)
        filter = skifeat.canny(gray ,sigma=Sigma   ,low_threshold=low_thresh     ,high_threshold=high_thresh)
        return filter
def allFilters():
    img = plt.imread("images\\coins.png")
    #mask = np.ones((246,300),dtype=np.uint8)

    roberts = highpass_filter("roberts",img)
    sobel = highpass_filter("sobel",img)
    scharr = highpass_filter("scharr",img)
    prewitt = highpass_filter("prewitt",img)
    laplace = highpass_filter("laplace",img,kSize=3)
    canny = highpass_filter("canny",img,Sigma=2,low_thresh=0.1,high_thresh=0.2)

    names = ["roberts","sobel","scharr","prewitt","laplace","canny"]
    filters = [roberts,sobel,scharr,prewitt,laplace,canny]
    for i in range(6):
        plt.subplot(230+i+1); plt.axis("off"); plt.title(names[i])
        plt.imshow(filters[i], cmap="gray")
    plt.show()
def exFour():
    img = plt.imread("images\\coins.png")
    filter = highpass_filter("canny",img)
    #printNoise(img,filter,"canny")
    allFilters()