#!/usr/bin/python3 -B
from pnm import *
from matrice import *


################
##            ##
## Exercice 1 ##
##            ##
################


## Question 1.1

from pnm import *
voir_fichier('space-invader-pieuvre.pbm',quadrillage=False)
voir_fichier('space-invader-soucoupe.pbm',quadrillage=False)


## Question 1.2


## Question 1.3

M = fichier_vers_matrice('space-invader-pieuvre.pbm')
print(M)


## Question 1.4

M = fichier_vers_matrice('space-invader-pieuvre.pbm')
M[3][4] = True
matrice_vers_fichier(M, 'space-invader-pieuvre2.pbm')
voir_fichier('space-invader-pieuvre2.pbm')





################
##            ##
## Exercice 2 ##
##            ##
################


def affiche_matrice_booleens(M, plein, vide):
    (n,m)=dimensions(M)
    for i in range(n):
        for j in range(m):
            if M[i][j]:
                print(plein, sep='', end='')
            else:
                print(vide, sep='', end='')
        print()

affiche_matrice_booleens(M,'#','.')





################
##            ##
## Exercice 3 ##
##            ##
################





## Question 3.1


def ajoute_horizontal(M1 , M2):
    """Construit une nouvelle matrice constituée des colonnes de M1 et à
        droite de celles de M2 (erreur si M1 et M2 n'ont pas le même
        nombre de lignes).
    """
    (n1, m1) = dimensions(M1)
    (n2, m2) = dimensions(M2)
    assert n1 == n2
    n=n1
    M = nouvelle_matrice(n,m1+m2)
    for i in range(n):
        for j in range(m1):
            M[i][j] = M1[i][j]
        for j in range(m2) :
            M[i][j+m1] = M2[i][j]
    return M

M = fichier_vers_matrice('space-invader-pieuvre.pbm')
M2 = ajoute_horizontal(M , M)
M3 = ajoute_horizontal(M2 , M)
matrice_vers_fichier(M3 , 'space-invader-3-pieuvres.pbm')
voir_fichier('space-invader-3-pieuvres.pbm')




## Question 3.2

def répète_horizontal(M, k):
    matrice = M
    for i in range(1,k):
        matrice = ajoute_horizontal(matrice,M)
    return matrice

M20 = répète_horizontal(M, 20)
matrice_vers_fichier(M20 , 'space-invader-20-pieuvres.pbm')
voir_fichier('space-invader-20-pieuvres.pbm')



## Question 3.3



def ajoute_vertical(M1,M2):
    (n1,m1) = dimensions(M1)
    (n2,m2) = dimensions(M2)
    n = n1+n2
    m = max(m1,m2)
    # On crée une matrice de la bonne taille
    M=nouvelle_matrice(n,m)
    # On complète le haut de la matrice M avec M1
    for i in range(n1):
        for j in range(m1): # m1<m donc M[i][j] bien définie
            M[i][j] = M1[i][j]
    # On complète le bas de la matrice M avec M1
    for i in range(n2): # i+n1 <= n2+n1 <= n donc M[i+n1] bien définie
        for j in range(m2): # m2<m donc M[i][j] bien définie
            M[i+n1][j] = M2[i][j]
    return M


M1 = fichier_vers_matrice('space-invader-pieuvre.pbm')
M2 = fichier_vers_matrice('space-invader-soucoupe.pbm')
M3 = ajoute_vertical(M1 , M2)
matrice_vers_fichier(M3,'space-invader-vertical.pbm')
voir_fichier('space-invader-vertical.pbm')

def ajoute_vertical_centré(M1,M2):
    (n1,m1) = dimensions(M1)
    (n2,m2) = dimensions(M2)
    n = n1+n2
    m = max(m1,m2)
    M=nouvelle_matrice(n,m)
    delta1 = (m-m1)//2 # L’écart à ajouter au début pour centrer la matrice Mk
    delta2 = (m-m2)//2 # Remarque si Mk est la plus grande, deltak sera nul (k=1 ou 2)
    for i in range(n1):
        for j in range(m1):
            M[i][j+delta1] = M1[i][j]
    for i in range(n2):
        for j in range(m2):
            M[i+n1][j+delta2] = M2[i][j]
    return M

M1 = fichier_vers_matrice('space-invader-pieuvre.pbm')
M2 = fichier_vers_matrice('space-invader-soucoupe.pbm')
M3 = ajoute_vertical_centré(M1 , M2)
matrice_vers_fichier(M3,'space-invader-vertical-centre.pbm')
voir_fichier('space-invader-vertical-centre.pbm')


## Question 3.4

def armée(nb_lignes, nb_pieuvres, nb_soucoupes):
    M1 = fichier_vers_matrice('space-invader-pieuvre.pbm')
    M2 = fichier_vers_matrice('space-invader-soucoupe.pbm')
    M1 = répète_horizontal(M1, nb_pieuvres)
    M2 = répète_horizontal(M2, nb_soucoupes)
    M = M1
    for i in range(1, nb_lignes): # On commence à 1, car au début  M=M1
        if i%2 == 0:
            M = ajoute_vertical_centré(M, M1)
        else:
            M = ajoute_vertical_centré(M, M2)
    return M

matrice_vers_fichier(armée(5, 20, 15), 'space-invader-armée.pbm')
voir_fichier('space-invader-armée.pbm')



################
##            ##
## Exercice 4 ##
##            ##
################



rouge   = (255,  0,  0)
vert    = (  0,255,  0)
bleu    = (  0,  0,255)
noir    = (  0,  0,  0)
blanc   = (255,255,255)
gris    = (127,127,127)
jaune   = (255,255,  0)
cyan    = (  0,255,255)
magenta = (255,  0,255)
M = [ [rouge,vert,bleu], [noir,blanc,gris], [jaune, cyan,magenta] ]
voir_matrice(M)





################
##            ##
## Exercice 5 ##
##            ##
################



from pnm import *
from chat import chat_mignon

(n,m)=dimensions(chat_mignon)
python_mignon = nouvelle_matrice(n,m)

for i in range(n):
    for j in range(m):
        (r,v,b) = chat_mignon[i][j]
        python_mignon[i][j] = (r//2, v//2, b//2)

voir_matrice(python_mignon)

(n,m)=dimensions(python_mignon)
for i in range(n):
    for j in range(m):
        (r,v,b) = python_mignon[i][j]
        moyenne = (r+v+b)//3
        python_mignon[i][j] = (moyenne, moyenne, moyenne)

voir_matrice(python_mignon)



################
##            ##
## Exercice 6 ##
##            ##
################



def est_yeux(i,j,matrice):
    (n,m) = dimensions(matrice)
    if matrice[i][j]: # si le pixel est noir
        return False
    if i in [0, n-1] or j in [0, m-1]: # si le pixel est sur un bord
        return False

    for a in range(i-1, i+2):
        for b in range(j-1, j+2):
            if (a,b) != (i,j): # on ignore le pixel i,j
                if not matrice[a][b]: # si le pixel est blanc
                    return False
    return True


def coloriser_matrice(fichier,corps, yeux, fond):
    M = fichier_vers_matrice(fichier)
    (n,m) = dimensions(M)
    C = nouvelle_matrice(n,m)
    for i in range(n):
        for j in range(m):
            if est_yeux(i,j,M):
                C[i][j] = yeux
            elif M[i][j]:
                C[i][j] = corps
            else:
                C[i][j] = fond
    return C

bleu    = (  0,   0, 255)
vert    = (  0, 255,   0)
rouge   = (255,   0,   0)
jaune   = (255, 255,   0)
cyan    = (  0, 255, 255)
magenta = (255,   0, 255)

C1 = coloriser_matrice('space-invader-pieuvre.pbm', bleu, vert, rouge)
voir_matrice(C1)


def remplir_matrice(M,x):
    (n,m)=dimensions(M)
    for i in range(n):
        for j in range(m):
            M[i][j] = x

# Je rajoute deux paramètres x et y pour indiquer les couleurs de fond
# de M1 (de couleur x) et M2 (de couleur y).
def ajoute_vertical_centré(M1,M2,x,y):
    (n1,m1) = dimensions(M1)
    (n2,m2) = dimensions(M2)
    n = n1+n2
    m = max(m1,m2)
    M=nouvelle_matrice(n,m)
    if m==m1:
        remplir_matrice(M, y)
    else:
        remplir_matrice(M, x)
    delta1 = (m-m1)//2
    delta2 = (m-m2)//2
    for i in range(n1):
        for j in range(m1):
            M[i][j+delta1] = M1[i][j]
    for i in range(n2):
        for j in range(m2):
            M[i+n1][j+delta2] = M2[i][j]
    return M


P1 = coloriser_matrice('space-invader-pieuvre.pbm', bleu, vert, rouge)
P2 = coloriser_matrice('space-invader-pieuvre.pbm', vert, bleu, rouge)
S1 = coloriser_matrice('space-invader-soucoupe.pbm', magenta, cyan, jaune)
S2 = coloriser_matrice('space-invader-soucoupe.pbm', cyan, magenta, jaune)

P = P1 # la ligne des pieuvres
S = S1 # la ligne des soucoupes
for i in range(10):
    if i%2==0:
        P = ajoute_horizontal(P,P2)
        S = ajoute_horizontal(S,S2)
    else:
        P = ajoute_horizontal(P,P1)
        S = ajoute_horizontal(S,S1)

M = P
for i in range(10):
    if i%2==0:
        M = ajoute_vertical_centré(M,S,rouge, jaune)
    else:
        M = ajoute_vertical_centré(M,P,jaune,rouge)


voir_matrice(M)