import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
import sys
import re
def getImage(filename:str,rows,cols):
    f = open(filename)
    text = f.read()
    # buffer = text.split("\t")
    # buffer = re.split("\t|\n|\ ",text)
    buffer = text.split()
    image = np.zeros((rows,cols))

    for i in range(rows):
        for j in range(cols):
            image[i,j] = float(buffer[cols*i+j])

    return image


def getDualHist(image0:np.array,image1:np.array):
    
    min = np.min([np.min(image0),np.min(image1)])
    max = np.max([np.max(image0),np.max(image1)])
    image0 = ((image0 -min)*255/(max-min)).astype(np.uint8)
    image1 = ((image1 -min)*255/(max-min)).astype(np.uint8)

    hist0 = np.zeros((256))
    hist1 = np.zeros((256))
    for i in range(image0.shape[0]):
        for j in range(image0.shape[1]):
            hist0[image0[i,j]] += 1
            hist1[image1[i,j]] += 1

    return min,max,hist0,hist1
        
def getHist(image:np.array,minmax = None):
    if(minmax):
        min = minmax[0]
        max = minmax[1]
    else:
        min,max = np.min(image),np.max(image)
    image = (image-min)*255/(max-min)
    image = image.astype(np.int32)
    hist = np.zeros(256)

    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            if(image[i,j]<256 and image[i,j] >=0):
                hist[image[i,j]] += 1

    return min, max,hist


def subImage(image0:np.array,image1:np.array)->np.array:
    img = image0-image1
    return img

def divImage(image0:np.array,image1:np.array)->np.array:
    img = image0/image1
    return img

def diedPoint(image:np.array, mask:np.array):
    threshold = np.sum(image*(1-mask))/np.sum(1-mask)/2
    # print("died point thre", threshold)
    mask = np.zeros(image.shape)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            mask[i,j] = 0 if image[i,j]>=threshold else 1
    return mask

def hotPoint(image:np.array,mask:np.array):
    threshold = np.sum(image* (1-mask))*2/np.sum(1-mask)
    # print("hot point thre ",threshold)
    mask = np.zeros(image.shape)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            mask [i,j] = 0 if image[i,j]<= threshold else 1
    return mask

def getValidPoint(image:np.array,noise:np.array):
    maskd = []
    maskd.append(np.zeros(image.shape))
    maskh = []
    maskh.append(np.zeros(image.shape))

    maskd.append( diedPoint(image,np.sign(maskh[-1]+maskd[-1])))
    maskh.append( hotPoint(noise, np.sign(maskh[-1]+maskd[-1])))
    # print(np.sum(maskd[-1]),np.sum(maskh[-1]))

 
    while True:

        maskd.append( diedPoint(image,np.sign(maskh[-1]+maskd[-1])))
        maskh.append( hotPoint(noise, np.sign(maskh[-1]+maskd[-1])))
        h = np.sum(maskh[-2])
        d = np.sum(maskd[-2])
        dh = np.sum(maskh[-1])-np.sum(maskh[-2])
        dd = np.sum(maskd[-1])-np.sum(maskd[-2])
        # print(d,dd,h,dh)
        if dd*1000<=d and dh*1000<=h:
            break
    return maskd[-1],maskh[-1]


        # maskdt = diedPoint
    

def getAnotherPoint(image:np.array,pos:(int,int),index:int):
    if image[pos] >= 0:
        return index,image
    image[pos] = index

    for row in range(-5,6):
        if pos[0]+row<0 or pos[0]+row>=image.shape[0]:
            continue
        for col in range(-5,6):
            if pos[1]+col<0 or pos[1]+col>=image.shape[1]:
                continue
            getAnotherPoint(image,(pos[0]+row,pos[1]+col),index)
    return index+1, image

    # if pos[0]-1>=0:
    #     if pos[1]-1 >=0:
    #         getAnotherPoint(image,(pos[0]-1,pos[1]-1),index)
    #     if pos[1]+1<image.shape[1]:
    #         getAnotherPoint(image,(pos[0]-1,pos[1]+1),index)
    # if pos[0]+1<image.shape[0]:
    #     if pos[1]-1 >=0:
    #         getAnotherPoint(image,(pos[0]+1,pos[1]-1),index)
    #     if pos[1]+1<image.shape[1]:
    #         getAnotherPoint(image,(pos[0]+1,pos[1]+1),index)

def getCluster(r:int,dirs:int,image:np.array,rs:int, cs:int):
    kernel = np.ones((2*r+1,2*r+1))
    for i in range(2*r+1):
        for j in range(2*r+1):
            if np.power(i-r,2)+np.power(j-r,2)>r*r:
                kernel[i,j] = 0

    mask = cv.dilate(image.astype(np.uint8),kernel.astype(np.uint8))
    num,rst = cv.connectedComponents(mask.astype(np.uint8),connectivity=dirs)
    cluster = np.zeros(num)
    log = []
    for i in range(num):
        log.append("第"+str(i)+"簇：")
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            if image[i,j]>0:
                cluster[int(rst[i,j])] += 1
                log[int(rst[i,j])]+="\n"+str(int(i+rs))+","+str(int(j+cs))
            else:
                rst[i,j] = 0

    # mask = -image
    # cluster = []
    # idx = 1
    # for i in range(image.shape[0]):
    #     for j in range(image.shape[1]):
    #         idx,mask = getAnotherPoint(mask,(i,j),idx)
    
    plt.imsave(str(image.shape[1])+"x"+str(image.shape[0])+".png",rst,cmap="Blues")
    f = open(str(image.shape[1])+"x"+str(image.shape[0])+".txt","w")
    
    # cluster = np.zeros(idx)
  

    # for i in range(image.shape[0]):
    #     for j in range(image.shape[1]):
    #         if mask[i,j] != 0:
    #             cluster[int(mask[i,j])] += 1
    #             log[int(mask[i,j])]+="\n"+str(int(i+rs))+","+str(int(j+cs))

    for i in range(1,num):
        log[i]+="\n共"+str(int(cluster[i]))+"个坏点"
        f.write(log[i]+"\n")
    f.close()
        
    return cluster

def calcCluster(r, dirs, image:np.array):

    # sys.setrecursionlimit(1000000)
    width = image.shape[0]
    height = image.shape[1]
    base = int(image.shape[1]/640)
    ret = []
    w = base*64
    h = base*64
    imtemp = image[int(width/2)-int(w/2):int(width/2)+int(w/2),int(height/2)-int(h/2):int(height/2)+int(h/2)]
    clu = getCluster(r,dirs, imtemp, width/2-imtemp.shape[0]/2, int(image.shape[1]/2)-imtemp.shape[1]/2)
    sum = len(clu)
    p = np.zeros(4)
    for i in range(1,len(clu)):
        if clu[i]<=3:
            p+=np.array([1,1,1,1])
        elif clu[i] <= 6:
            p+=np.array([0,1,1,1])
        elif clu[i] <= 12:
            p+= np.array([0,0,1,1])
        else:
            p+= np.array([0,0,0,1])
    ret.append(sum-1)
    ret.append(p[0])
    ret.append(p[1]-p[0])
    ret.append(p[3]-p[1])

    ret.insert(0,str(imtemp.shape[0])+"x"+str(imtemp.shape[1]))
    # ret.append(p[3]-p[2])
    w = base*128
    h = base*128
    imtemp = image[int(width/2)-int(w/2):int(width/2)+int(w/2),int(height/2)-int(h/2):int(height/2)+int(h/2)]
    clu = getCluster(r,dirs, imtemp, width/2-imtemp.shape[0]/2, int(image.shape[1]/2)-imtemp.shape[1]/2)
    sum = len(clu)
    p = np.zeros(4)
    for i in range(1,len(clu)):
        if clu[i]<=3:
            p+=np.array([1,1,1,1])
        elif clu[i] <= 6:
            p+=np.array([0,1,1,1])
        elif clu[i] <= 12:
            p+= np.array([0,0,1,1])
        else:
            p+= np.array([0,0,0,1])
    ret.append(sum-1)
    ret.append(p[0])
    ret.append(p[1]-p[0])
    ret.append(p[3]-p[1])
    ret.insert(1,str(imtemp.shape[0])+"x"+str(imtemp.shape[1]))

    # ret.append(p[3]-p[2])
    w = base*256
    h = base*320
    imtemp = image[int(width/2)-int(w/2):int(width/2)+int(w/2),int(height/2)-int(h/2):int(height/2)+int(h/2)]
    clu = getCluster(r,dirs,imtemp, width/2-imtemp.shape[0]/2, int(image.shape[1]/2)-imtemp.shape[1]/2)
    sum = len(clu)
    p = np.zeros(4)
    for i in range(1,len(clu)):
        if clu[i]<=3:
            p+=np.array([1,1,1,1])
        elif clu[i] <= 6:
            p+=np.array([0,1,1,1])
        elif clu[i] <= 12:
            p+= np.array([0,0,1,1])
        else:
            p+= np.array([0,0,0,1])
    ret.append(sum-1)
    ret.append(p[0])
    ret.append(p[1]-p[0])
    ret.append(p[3]-p[1])
    ret.insert(2,str(imtemp.shape[0])+"x"+str(imtemp.shape[1]))

    # ret.append(p[3]-p[2])

    image[int(width/2)-int(w/2):int(width/2)+int(w/2),int(height/2)-int(h/2):int(height/2)+int(h/2)] = 0

    clu = getCluster(r,dirs,image,0,0)
    sum = len(clu)
    p = np.zeros(4)
    for i in range(1,len(clu)):
        if clu[i]<=3:
            p+=np.array([1,1,1,1])
        elif clu[i] <= 6:
            p+=np.array([0,1,1,1])
        elif clu[i] <= 12:
            p+= np.array([0,0,1,1])
        else:
            p+= np.array([0,0,0,1])
    ret.append(sum-1)
    # ret.append(p[1]-p[0])
    ret.append(p[2]-p[1])
    ret.append(p[3]-p[2])

    ret.insert(3,str(imtemp.shape[0])+"x"+str(imtemp.shape[1])+"之外")

    return ret


def getEF(ms2:np.array, ms15:np.array):
    a = np.abs( np.average(ms15) - np.average(ms2))*1000
    b = np.std(ms15-ms2)*1000
    return [a,b]