import numpy as np
import cv2
import random

# ================================
# 1. Cargar imagen
# ================================
#imagen = "imagen1.png"
#imagen = "imagen2.jpeg"
imagen = "imagen3.png"
img = cv2.imread(imagen, 0) / 255.0

# ================================
# 2. Transformación sigmoide
# ================================
def sigmoide(img, alpha, delta):
    g = 1 / (1 + np.exp(-alpha * (img - delta)))
    return (g - g.min()) / (g.max() - g.min())

# ================================
# 3. Funciones objetivo
# ================================
def entropia(img):
    hist = cv2.calcHist([(img*255).astype(np.uint8)], [0], None, [256], [0,256])
    p = hist / hist.sum()
    p = p[p > 0]
    return -np.sum(p * np.log2(p))

def desviacion(img):
    return np.std(img)

# ================================
# 4. Evaluación (elige modelo)
# ================================
def evaluar(ind, modelo):
    alpha, delta = ind
    img2 = sigmoide(img, alpha, delta)

    if modelo == "entropia":
        return entropia(img2)
    else:
        return desviacion(img2)

# ================================
# 5. Crear individuo
# ================================
def crear_ind():
    return [random.uniform(0,10), random.uniform(0,1)]

# ================================
# 6. Selección
# ================================
def torneo(pob, fit):
    i, j = random.sample(range(len(pob)), 2)
    return pob[i] if fit[i] > fit[j] else pob[j]

# ================================
# 7. Cruza
# ================================
def cruza(p1, p2):
    return [(p1[0]+p2[0])/2, (p1[1]+p2[1])/2], [(p1[0]+p2[0])/2, (p1[1]+p2[1])/2]

# ================================
# 8. Mutación
# ================================
def mutar(ind):
    if random.random() < 0.2:
        ind[0] += random.uniform(-1,1)
    if random.random() < 0.2:
        ind[1] += random.uniform(-0.1,0.1)

    ind[0] = min(max(ind[0],0),10)
    ind[1] = min(max(ind[1],0),1)
    return ind

# ================================
# 9. Algoritmo genético
# ================================
def AG(modelo):
    POP = 10
    poblacion = [crear_ind() for _ in range(POP)]
    fitness = [evaluar(ind, modelo) for ind in poblacion]

    evaluaciones = POP

    while evaluaciones < 40:
        nueva = []

        while len(nueva) < POP:
            p1 = torneo(poblacion, fitness)
            p2 = torneo(poblacion, fitness)

            h1, h2 = cruza(p1, p2)
            nueva.append(mutar(h1))
            nueva.append(mutar(h2))

        poblacion = nueva[:POP]
        fitness = [evaluar(ind, modelo) for ind in poblacion]
        evaluaciones += POP

    mejor = poblacion[np.argmax(fitness)]
    return mejor

# ================================
# 10. Ejecutar ambos modelos
# ================================
for modelo in ["entropia", "desviacion"]:
    mejor = AG(modelo)

    img_final = sigmoide(img, mejor[0], mejor[1])
    cv2.imwrite(f"{modelo}_{imagen}", (img_final*255).astype(np.uint8))

    print(modelo, "->", mejor)