import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import imageio as io



#print(M[600,600])

#question 3.1

def drapeau():
    drap = np.zeros((600,900,3),dtype=np.uint8)
    drap[:,:300,2]=255
    drap[:,300:600]=255
    drap[:,600:900,0]=255
    plt.imshow(drap)
    plt.show()

#question 3.2

def symetrie2(image):
    IM=mpimg.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s = IM.shape
    image_symetrique = np.zeros_like(IM)
    for i in range(n):
        for j in range(p):
            image_symetrique[i, j] = IM[i, p-1-j]
    plt.imshow(image_symetrique)
    plt.show()

def symetrie(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s = IM.shape
    image_symetrique = np.zeros_like(IM)
    for i in range(n):
        for j in range(p):
            image_symetrique[i, j] = IM[i, p-1-j]
    plt.imshow(image_symetrique)
    plt.show()



#question 3.3

def rotation(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(M)
    n,p,s = IM.shape
    image_rot = np.zeros((p,n,s), dtype=np.uint8)
    for i in range(n):
        for j in range(p):
            image_rot[p-1-j,i] = IM[i,j]
    plt.imshow(image_rot)
    plt.show()

#question 3.4

def negatif(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s = IM.shape
    image_neg = np.zeros_like(IM)
    for i in range(n):
        for j in range(p):
            image_neg[i,j] = [255,255,255]-IM[i,j]
    plt.imshow(image_neg)
    plt.show()

#question 3.5

def luminance(p):
    return int(0.2126*p[0] + 0.7152*p[1] + 0.0722*p[2])

def niveaudegris(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s= IM.shape
    image_gris = np.zeros((n,p,s), dtype=np.uint8)
    for i in range(n):
        for j in range(p):
            image_gris[i,j] = luminance(IM[i,j])
    plt.imshow(image_gris)
    plt.show()



#Question 4.1

def convolution(M,c):
    n,p,q = M.shape
    MM = np.zeros_like(M)
    for i in range(1, n-1):
        for j in range(1, p-1):
            s = 0
            for u in range(3):
                for v in range(3):
                    s += c[u, v] * M[i-1+u, j-1+v]
                for k in range(q):
                    if s[k] < 0:
                        MM[i,j,k] = 0
                    elif s[k] > 255:
                        MM[i,j,k] = 255
                    else:
                        MM[i,j,k] = s[k]
    return MM


#Question 4.2

def lissage(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    c=1/9*np.ones((3,3),dtype=float)
    plt.imshow(convolution(IM,c))
    plt.show()

def contraste(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    c=np.array([[0,-1,0],[-1,5,-1],[0,-1,0]],dtype=float)
    plt.imshow(convolution(IM,c))
    plt.show()

def repoussage(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    c=np.array([[-2,-1,0],[-1,1,1],[0,1,2]])
    plt.imshow(convolution(IM,c))
    plt.show()
  
    


#Question 5.1

    

def gradient(image):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s= IM.shape
    L = np.zeros((n,p,s), dtype=np.uint8)
    for i in range(n):
        for j in range(p):
            L[i,j] = luminance(IM[i,j])
    L=L[:,:,:1]
    n,p,s=L.shape
    grad=np.zeros((n,p,1),dtype=float)
    c1=np.array([[-1,0,1],[-2,0,2],[-1,0,1]],dtype=float)
    c2=np.array([[-1,-2,-1],[0,0,0],[1,2,1]],dtype=float)
    for i in range(1,n-1):
        for j in range(1,p-1):
            s1=0
            s2=0
            for u in range(3):
                for v in range(3):
                    s1 += (c1[u,v]*L[i-1+u,j-1+v])
                    s2 += (c2[u,v]*L[i-1+u,j-1+v])
            S=(s1**2+s2**2)
            grad[i,j]=S
    return grad


  #Question 5.2

def contour(image,seuil):
    IM=io.imread(image)[:,:,:3]
    IM=np.array(IM)
    n,p,s= IM.shape
    grad=gradient(image)
    image_c=np.zeros_like(IM)
    for i in range(n):
        for j in range(p):
            if grad[i,j]<seuil:
                image_c[i,j]=255
    plt.imshow(image_c)
    plt.show()

    

#Question 6

E=io.imread("einstein2.png")[:,:,:3]

E=np.array(E)

M=io.imread("malherbe.png")[:,:,:3]

M=np.array(M)

#malherbe_sans_bits_forts=(M>>6)<<6

#plt.imshow(malherbe_sans_bits_forts)
#plt.show()

malherbesurprise=((M>>3)<<3)+(E>>5)

io.imwrite("malherbesurprise.png",malherbesurprise)

vraie=malherbesurprise<<5

plt.imshow(vraie)

plt.show()