# -*- coding:Utf-8 -*-
"""
    morphology_find06.py
    poursuite de la recherche entreprie avec les précédents.
    On va charger séparément les couches rouge, vert et bleu
    im est remplacée par im3couches
    imr = tableau pour la couche rouge
    vert = tableau pour la couche verte
    imb = tableau pour la couche bleue
    IMPORTANT : distinguer image "de brouillon" = "im" et image de travail
    Le travail est d'abord expérimenté  sur la couche verte
"""
from PIL import Image
from scipy.ndimage import find_objects,label,sum
import numpy as np

def charge_image(nom):
    """
        nom : type string = nom du fichier
        - test d'existence du fichier
        si oui, retourne un triple tableau de valeurs
        si non : message d'erreur et retour d'une chaine vide
    """
    try:
        Image.open(nom)
    except:
        print("Le fichier "+nom+" est introuvable")
        return ""
    else:
        return np.array(Image.open(nom))

def masque_seuil_haut(im,seuil):
    """
       Crée un tableau annexe, de dimensions égales à celles de l'image
       contenant 0 pour toute cellule de l'image inférieure ou égale au seuil
       contenant 1  pour toute cellule de l'image supérieure au seuil
    """
    return 1*(im>seuil)


def masque_seuil_bas(seuil):
    """
       Crée un tableau annexe, de dimensions égales à celles de l'image
       contenant 0 pour toute cellule de l'image supérieure ou égale au seuil
       contenant 1  pour toute cellule de l'image inférieure au seuil
    """
    return 1*(im<seuil)

def elimine_pixels_faibles(im,seuil):
    """
        Tous les pixels dont la valeur est inférieure au seuil sont éliminés
        par application d'un seuil
    """
    masque_bas = masque_seuil_haut(im,seuil)
    return im * masque_bas

def repere_etoiles(im):
    """
        retourne une liste de tuples permettant de positionner chacune des étoiles
        retourne un int pour le nombre d'objets trouvés
    """
    labels,nombre_objets = label(im)
    return find_objects(labels),nombre_objets

def liste_positionxy_valeur(y,x,vert):
    """
        lister la valeur de chaque pixel au centre
        d'une image
    """    
    for i in range(len(x)):
        print("Position  y = {} x = {} valeur du pixel : {} ".\
        format(y[i], x[i], vert[y[i]][x[i]]))


def affiche_les_objets(im,nombre_objets,slices,mini):
    """
        liste 
    """
    for i in range(nombre_objets):
        if sum(im[slices[i]]) > mini:
            print("Objet numero : {}".format(i))
            print(im[slices[i]])
            print("Somme des pixels : {} ".format(sum(im[slices[i]])))
            print('-----      -----')



def coordonnees_des_centres(slices):
    """
        Détermine la position en x et y des centres de chacune des étoiles repérées
    """
    x, y = [ ], [ ] 
#    for dy,dx in slices:
    for dx,dy in slices:
        x_center =(dx.start + dx.stop) /2
        x.append(x_center)
        y_center = (dy.start + dy.stop)/2
        y.append(y_center)
        #print("Position du centre x = {} y = {} ".format(x_center,y_center))
    return x,y
    


def bornes( pos_y, pos_x, largeur, hauteur, demi_cote):
    """
        pos_x, pos_y, largeur, hauteur = int
        pos_x = coordonnée en x du centre de l'étoile
        pos_y = coordonnée en y du centre de l'étoile
        largeur et hauteur de l'image
        Détermine les bornes de la recherche dans l'image de façon à éviter
        les erreurs de "sortie du cadre"
    """
    max_g, max_d, max_h, max_b = 0, 0, 0, 0
    # print("demi cote "+str(demi_cote))
    max_g = pos_x - demi_cote
    if max_g < 0:
        max_g = 0
    max_d = pos_x + demi_cote
    if max_d >= largeur:
        max_d = largeur -1
    max_h = pos_y - demi_cote
    if max_h < 0:
        max_h = 0
    max_b = pos_y + demi_cote
    if max_b >= hauteur:
        max_b = hauteur -1
    return max_g, max_d, max_h, max_b

def fichier_les_objets(im,nombre_objets,slices,mini):
    """
        liste 
    """
    for i in range(nombre_objets):
        if sum(im[slices[i]]) > mini:
            sortie.write("Objet numero : {} \n".format(i))
            #sortie.write(im[slices[i]])
            sortie.write("Somme des pixels : {}\n ".format(sum(im[slices[i]])))
            print('-----      -----')




def cree_masque_transfert(y, x, n, image):
    """   """
    max_g,max_d,max_h,max_b = bornes(y, x, largeur, hauteur, carre_recherche / 2)
    
    sortie.write("Objet N° {} Bornes gauche {} droite {}   haut {}  bas {} \n".format(n,max_g,max_d,max_h,max_b))
    somme_pixels = 0
    
    for j in range(max_h,max_b):
        for i in range(max_g,max_d):
            if image[j][i] > seuil_bas:
                masque_transfert[j][i] = image[j][i]
                sortie.write(" {} ".format(image[j][i]))
                # image[j][i] = 0
            else:
                sortie.write(" {} ".format(image[j][i]))
        sortie.write(" \n")        
    somme_pixels = masque_transfert.sum()
    sortie.write("Somme des pixels de cette étoile {} \n".format(somme_pixels))
    return somme_pixels,max_g,max_d,max_h,max_b