import time


def BWRAT(img):
    Lx=img.shape[1]; Ly=img.shape[0]; A1=Lx*Ly
    if(A1<100): return 0,0,0
    if(A1>50000): print('A1=',A1,Lx,Ly); return 0,0,0
    Lx2=int(Lx/4); Ly2=int(Ly/4); A=Lx2*Ly2
    im1=np.copy(img)
    im2=cv2.resize(im1,(Lx2,Ly2))
    gray=cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)
    ret,bina=cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)     
    NWT=0; NB=0;
    for x in range(Lx2):
        for y in range(Ly2):
            if(bina[y,x]<40): NB+=1
            if(gray[y,x]>150): NWT+=1
    rat=round(NB/A,3); ratW=round(NWT/A,3)
    if(0.1<rat<0.9): KBW=1
    else: KBW=0
    if(ratW<0.1): KBW=0; 
    return KBW,ratW,rat


def HLA(hsv):
    Lx=hsv.shape[1]; Ly=hsv.shape[0]; hv=[]; N10=int(Lx/10)*1
    BW=[]
    for j in range(Lx):
        for i in range(Ly):
            if(hsv[i,j,2]>120 and hsv[i,j,1]>100): continue
            BW.append(int(hsv[i,j,2]))
    shv=sorted(BW)
    L1=int(len(shv)/10); H1=L1*9
    if(L1<2 or len(shv)<2): return 0,0
    avL=int(np.average(shv[0:L1]))
    avH=int(np.average(shv[H1:len(shv)]))
    return avL,avH






def highlow(hsv,Y):
    rH=0.4; rL=0.1
    Lx=hsv.shape[1]; Ly=hsv.shape[0]; hv=[]; N10=int(Lx/10)*1
    for j in range(N10,N10*9):
        hv.append(int(hsv[Y,j,2]))
    shv=sorted(hv)
    NH=int(Lx*rH); NL=int(Lx*rL)
    H10=int(np.average(shv[-NH:-1]))
    L10=int(np.average(shv[0:NL]))
    return H10,L10


def high10(hsv,Y):
    Lx=hsv.shape[1]; Ly=hsv.shape[0]; hv=[]; N10=int(Lx/10)*1+1
    for j in range(int(Lx/4),int(3*Lx/4)):
        hv.append(int(hsv[Y,j,2]))
    shv=sorted(hv)
    H10=int(np.average(shv[-N10:-1]))
    L10=int(np.average(shv[0:N10]))
    return H10,L10


def scancrop(img):
    #img=cv2.imread('crop2.png')
    #cv2.imshow('img_cr',img); #cv2.waitKey(0)
    Lx=img.shape[1]; Ly=img.shape[0]; Lx0=Lx; Ly0=Ly; YC=int(Ly/2)
    im1=np.copy(img)
    im2=np.copy(img)
    im3=np.copy(img)
    #ret,bina=cv2.threshold(im1, 40, 255, cv2.THRESH_BINARY)     
    imgL=np.copy(img)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    H10,L10=high10(hsv,YC)
    #print('scancrop_H10,L10=',H10,L10)
    NXS=40; XS=[int(Lx/NXS*1) for i in range(NXS)]; 
    NYS=40; YS=[int(Ly/NYS*i) for i in range(NYS)]; 
    #print('XS=',XS,int(Lx/NXS*(NXS/2)))
    #print(img.shape,Ly,'YS=',YS,int(Ly/NYS*(NYS/2)))
    XC=XS[int(NXS/2)]; YC=YS[int(NYS/2)]
    #cv2.line(imgL,(0,YC),(Lx-1,YC),(0,255,0),4)
    #cv2.line(imgL,(XC,0),(XC,Ly-1),(255,0,0),4)
    #cv2.imshow('imgL',imgL); #cv2.waitKey(0)
    SW=[]; YX=-1; SWX=0; CLR=[]
    for jy in range(NYS):
        NCLR=0; Y=YS[jy]
        for j in range(1,Lx-2):
            if(hsv[Y,j-1,2]>120 and hsv[Y,j-1,1]>60): NCLR+=1
        CLR.append(NCLR)
        #if(NCLR>Lx*0.2): print('COLOR H-LINE:',jy,Y,NCLR)

    #YY=YS[36]
    #cv2.line(im3,(0,YY),(Lx-1,YY),(0,255,0),4)
    #cv2.imshow('im3',im3)
    for jy in range(NYS):
        Y=YS[jy]; NBW=0; NWB=0; 
        NCC=0; NW=0; NB=0
        H10,L10=high10(hsv,Y); D10=H10-L10; DCX=int(D10*0.8)
        if(H10<50): 
            #print(jy,Y,H10,L10); 
            SW.append(0); continue
        for j in range(1,Lx-2):
            D1=int(hsv[Y,j-1,2]); D2=int(hsv[Y,j,2])
            D3=int(hsv[Y,j+1,2]); D4=int(hsv[Y,j+2,2])
            DC1=D1+D2-D3-D4; DC2=D3+D4-D1-D2
            if(DC2>DCX): NBW+=1
            if(DC1>DCX): NWB+=1
            if(hsv[Y,j-1,2]<L10): NB+=1
            if(hsv[Y,j-1,2]>H10*0.7): NW+=1
            #if(hsv[Y,j-1,2]<60 and hsv[Y,j,2]>180): NBW+=1
            #if(hsv[Y,j-1,2]>180 and hsv[Y,j,2]<60): NWB+=1  
        Ncross=NBW+NWB
        if(NW>0): ratBW=round(NB/NW,3)
        else: ratBW=100
        if(ratBW>1.2): Ncross=0
        if(Ncross>SWX): SWX=Ncross; YX=jy
        #print(jy,Y,'SWX=',SWX,NBW,NWB,Ncross,'NB,W=',NB,NW,ratBW,'H,L=',H10,L10)
        SW.append(Ncross); 
    SWXC=int(SWX*0.4)
    #print('SW=',SW,SWXC,NCC)
    #print('CLR=',CLR)
    Yx=0
    for i in range(0,NYS):
        if(SW[i]>SWXC): Yx=i;break
    Yn=NYS-1
    for i in range(NYS-1,-1,-1):
        if(SW[i]>SWXC): Yn=i;break
    if(Yn<NYS-3): Yn+=3
    if(Yx>2): Yx-=3
    Y1=YS[Yx]; Y2=YS[Yn]
    #print(YX,Yx,Yn,SW[YX],SW[Yx],SW[Yn],'Y1,2=',Y1,Y2)
    if(YX==-1 or Y1>=Y2): 
        print('Ksc error, YX,Y1Y2=',YX,Y1,Y2)
        Ksc=0; #cv2.waitKey(0)
        return Ksc,img,0,0,0,0
    imgy=img[Y1:Y2,:,:]
    cv2.imshow('imgy',imgy); 
    #cv2.waitKey(0)
    #..............................................X-scan....
    Lx=imgy.shape[1]; Ly=imgy.shape[0]
    #print('imgy.shape=',imgy.shape)
    hsv=cv2.cvtColor(imgy,cv2.COLOR_BGR2HSV)
    SW=[]; XX=-1; SWX=0
    #for i in range(Lx): print(i,'hsvYC=',hsv[YC,i,:],img[YC,i,:])
    #for i in range(Ly): print(i,XC,'hsvXC=',hsv[i,XC,:],img[i,XC,:])
    #print('Ly/2=',Ly/2,' Lx=',Lx,NXS,Lx/NXS)
    Dy=Y2-Y1
    a=hsv[int((Y2-Y1)/2),:,:]
    aa=hsv[int((Y2-Y1)/2),:,2]
    #print('a=',a)
    b=sorted(aa)
    NXA=int(Lx*0.6)
    NXB=int(Lx*0.3)
    bb=b[-NXA:-1]
    bc=b[0:NXB]
    bav=int(np.average(bb))
    cav=int(np.average(bc))
    #print('b20=',b[-NXA:-1])
    #print('bav=',bav,' cav=',cav,' Dy=',Dy,int(Dy/2))
    X1=0
    for jx in range(Lx):
        X=jx; NW=0; NB=0
        for j in range(2,Dy-3):
            if(hsv[j,X,2]>100 and hsv[j,X,1]>80): continue
            if(hsv[j,X,2]>bav): NW+=1
            if(hsv[j,X,2]<cav): NB+=1
        #print('jx1,X=',jx,X,NW,NB)
        if(NW>Dy*0.5): X1=X; break
        if(NW>5 and NB>5 and NW+NB>Ly*0.4): X1=X; break
    X2=Lx-1
    for jx in range(Lx-1,0,-1):
        X=jx; NW=0; NB=0
        for j in range(2,Dy-3):
            if(hsv[j,X,2]>100 and hsv[j,X,1]>80): continue
            if(hsv[j,X,2]>bav): NW+=1
            if(hsv[j,X,2]<cav): NB+=1
        #print('jx2,X=',jx,X,NW,NB,NW+NB)
        if(NW>Dy*0.5): X2=X; break
        if(NW>5 and NB>5 and NW+NB>Ly*0.4): X2=X; break

    #print('scan_ending,Y1,Y2,X1,X2=',Y1,Y2,X1,X2)
    im5=img[Y1:Y2,X1:X2]
    print('0-img.shape=',img.shape,'1-imgy.shape=',imgy.shape,'2-im5.shape=',im5.shape)
    EEX=int((X2-X1)*0.05); EEY=int((Y2-Y1)*0.05)
    #print('EEX,EEY=',EEX,EEY,'BX1=',X1,X2,Y1,Y2,im5.shape,'Ly=',Ly,Ly-EEY,Y2)
    if(X1>EEX):X1-=EEX
    if(X2<Lx0-EEX):X2+=EEX
    if(Y1>EEY):Y1-=EEY
    if(Y2<Ly0-EEY):Y2+=EEY
    im2=img[Y1:Y2,X1:X2]
    #print('X1,X2,Y1,Y2=',X1,X2,Y1,Y2,'imgy,im2.shape=',imgy.shape,im2.shape)
    #cv2.imshow('im5_F',im5); #cv2.waitKey(0)
    #cv2.imshow('im2_F',im2); #cv2.waitKey(0)
    Ksc=1
    if(X2<=X1): Ksc=0
    return Ksc,im2,Y1,Y2,X1,X2



def CLR(img):
    Lx=img.shape[1]; Ly=img.shape[0]
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    NC=0; NCY=0; dy=int(Ly/10); dx=int(Lx/10); color=[]; #print('dx2=',dx*2)
    for Y in range(dy*3,dy*9,dy):
        NC=0; cc=[]
        for j in range(dx*2,dx*8):
            if(hsv[Y,j,2]>100 and hsv[Y,j,1]>120): NC+=1; cc.append((Y,j,hsv[Y,j,:]))
        color.append((Y,NC))
        if(NC>(dx*2)): 
            NCY+=1; 
            #for t in range(dx*2,dx*8): print(Y,t,img[Y,t,:],hsv[Y,t,:])
            #cv2.imshow('1COLOR',img); cv2.waitKey(0)
    #print('NCY=',NCY,len(color),color)
    #if(NCY==1): print('error NCY=',NCY); cv2.imshow('1COLOR',img)
    if(NCY>1): 
        KCLR=0; 
        #print('error NCY=',NCY); cv2.imshow('COLOR',img); cv2.waitKey(0)
    else: KCLR=1
    #cv2.imshow('imgcolor',img)
    #cv2.waitKey(0)
    return KCLR






def DBKWT(img):
    Lx=img.shape[1]; Ly=img.shape[0]
    Lx2=int(Lx/10); Ly2=int(Ly/10); RX=40; RY=int(Ly/Lx*RX)
    im1=np.copy(img)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    if(Lx>=RX):
        imgrs=cv2.resize(img,(RX,RY))
    else:
        imgrs=np.copy(img)
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    a=hsvrs[:,:,2]; aa=a.ravel(); sa=np.sort(aa);L10=int(len(sa)/10)
    L10=int(np.average(sa[0:L10])); H10=int(np.average(sa[-L10:-1])); D10=H10-L10
    #print(img.shape,'a.shape=',a.shape,sa.shape,' sa=',sa)
    avL,avH=HLA(hsvrs); Dav=avH-avL
    #print('av:',avL,L10,avH,H10,' Dav,D10=',Dav,D10)
    if(Dav<60 or L10>120 or H10<160):
        #print('fail_DB',L10,H10,Dav); 
        return 0,avH,avL,Dav
    else: return 1,avH,avL,Dav



def SCHL(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly
    im1=np.copy(img)
    if(Lx>400):
        imgrs=cv2.resize(img,(int(Lx/10),int(Ly/10))); SX=10
    elif(40<Lx<=400):
        imgrs=cv2.resize(img,(int(Lx/5),int(Ly/5))); SX=5
    else: imgrs=np.copy(img); SX=1
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    Lx2=hsvrs.shape[1]; Ly2=hsvrs.shape[0]
    #print('===in SCHL...',img.shape,imgrs.shape)
    NY=20; YS=[int(Ly2/NY*i) for i in range(NY)]; NHL=0; YHL=[]
    for j in range(NY):
        Y=YS[j]
        a=hsvrs[Y,:,2]; sa=np.sort(a); LC=int(len(sa)/4)
        L10=int(np.average(sa[0:LC])); H10=int(np.average(sa[-LC:-1])); D10=H10-L10
        #print('LC=',LC,L10,H10,D10)
        if(L10>100 or H10<180): continue
        NSW=0; SW=[]
        for i in range(Lx2-1):
            if(abs(int(hsvrs[Y,i,2])-int(hsvrs[Y,i+1,2]))>D10*0.7): NSW+=1; SW.append(i)
        if(NSW>8):
            NHL+=1
            #print('NSW>2: NSW=',NSW,j,Y,Y*SX,' NHL=',NHL,' SW=',SW)
            cv2.line(imgrs,(0,Y),(Lx2,Y),(255,0,0),1)
            cv2.line(im1,(0,Y*SX),(Lx,Y*SX),(255,0,0),1)
            YHL.append(Y*SX)
    #cv2.imshow('imgrs',imgrs)
    if(NHL>0): 
        KHL=1; 
        if(NHL==1): 
            Y1=int(YHL[0]-SX*YS[1]*3); Y2=Y1+int(2*SX*YS[1]*3)
        else: Y1=int(YHL[0]-SX*YS[1]*3); Y2=int(YHL[NHL-1]+2*SX*YS[1]*3)
        #print('NHL=',NHL,' YHL=',YHL,' Y1,2=',Y1,Y2)
    else: KHL=0; Y1=YS[0]; Y2=YS[-1]
    if(Ly<150): Y1=Yin1; Y2=Yin2
    #cv2.imshow('im1',im1)
    #cv2.waitKey(0)
    return KHL,NHL,Y1,Y2









def censcan(img):
    Lx=img.shape[1]; Ly=img.shape[0]
    im1=np.copy(img)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    imgrs=cv2.resize(img,(int(Lx/10),int(Ly/10)))
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsvrs)
    YC=int(Ly/2); NC=0; NBW=0; NWB=0; Y=YC; NW=0; NB=0
    H10,L10=high10(hsv,Y); D10=H10-L10; Dav=avH-avL
    DCX=int(Dav*0.7)*1
    #print('cen,H,L=',H10,L10,' av:',avH,avL,DCX,hsvrs.shape)
    #if(D10<60 and Dav<60): return 0,0
    CLR=0
    for j in range(1,Lx-2):
        if(hsv[Y,j,2]>180 and hsv[Y,j,1]>150): CLR+=1; #print(j,CLR,hsv[Y,j,:],img[Y,j,:]);
    #if(CLR>Lx*0.1): print('CLR>0.1*Lx:',CLR,Lx)
    if(CLR>Lx*0.2): return 0,0
    for j in range(1,Lx-2):
        D1=int(hsv[Y,j-1,2]); D2=int(hsv[Y,j,2])
        D3=int(hsv[Y,j+1,2]); D4=int(hsv[Y,j+2,2])
        DC1=D1+D2-D3-D4; DC2=D3+D4-D1-D2
        if(DC2>DCX): NBW+=1
        if(DC1>DCX): NWB+=1
        if(hsv[Y,j-1,2]<avL): NB+=1
        if(hsv[Y,j-1,2]>avH*0.7): NW+=1
    NSW=NBW+NWB
    if(NW>0): ratBW=round(NB/NW,3)
    else: ratBW=100
    if(ratBW>1.2): NSW=0
    #print('EXcen:',NSW,NBW,NWB,' H10=',H10,L10,D10)
    if(NWB>3 or NBW>3 or NSW>7): 
        KC=1; 
        #print('excellent:',H10,L10,D10)
    else: KC=0; #print('EX_KC=0:',NBW,NWB,NSW); cv2.imshow('cen',img); cv2.waitKey(0)
    #cv2.imshow('im1',im1); cv2.waitKey(0)
    return KC,NSW





def TVS(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Ly1=int(Ly/10)
    im1=np.copy(img)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    YC=int(Ly/2); NC=0; NBW=0; NWB=0; cut=[]; bkdot=[]
    YB=[]; XS=[int(Lx/20)*i for i in range(20)]
    for j in range(20):
        x=XS[j]
        NSW=0; SW=[]
        for i in range(Ly1*2,Ly-Ly1*2):
            KW=1
            if(hsv[i,x,2]<120): 
                NSW+=1; 
                cv2.circle(im1,(x,i),1,(255,0,0),-1)
            if(NSW>10): KW=0; break
        if(KW==1): YB.append(i); #print(x,NSW,len(YB)) #,hsv[:,x,2]); 
    LYB=len(YB)
    ratV=round(LYB/20,2)
    #print('TVS_len(YB)=',len(YB))
    #cv2.imshow('TVS_im1',im1)
    #cv2.waitKey(0)
    return LYB,ratV




def vscan(img):
    Lx=img.shape[1]; Ly=img.shape[0]
    im1=np.copy(img)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    YC=int(Ly/2); NC=0; NBW=0; NWB=0; cut=[]; bkdot=[]
    YB=[]
    for i in range(Ly):
        NSW=0; SW=[]
        for j in range(Lx-1):
            if(abs(int(hsv[i,j,2])-int(hsv[i,j+1,2]))>40): 
                NSW+=1; SW.append(j)
                cv2.circle(im1,(j,i),4,(255,0,0),-1)
        if(NSW>5): YB.append(i); #print(i,NSW,SW); 
    if(len(YB)==0): return []
    Y1=min(YB); Y2=max(YB)
    if(Y1>5):Y1=Y1-5
    if(Y2<Ly-5): Y2=Y2+5
    imgY=img[Y1:Y2,:,:]
    #cv2.imshow('YB',im1)
    #cv2.imshow('imgY',imgY)
    #cv2.waitKey(0)
    #-------------------------------------
    imgX=np.copy(imgY)
    im1=np.copy(imgX)
    hsv=cv2.cvtColor(imgX,cv2.COLOR_BGR2HSV)
    Lx=imgX.shape[1]; Ly=imgX.shape[0]
    NBK=0
    for j in range(Lx):
        NBK=0
        for i in range(Ly):
            if(hsv[i,j,2]<150): 
                NBK+=1
                cv2.circle(im1,(j,i),1,(255,0,0),-1)
        bkdot.append(NBK)
        #print(j,'NBK=',NBK)
    mnbk=min(bkdot); lenbk=len(bkdot)
    #print('mnbk=',mnbk,' lenbk=',lenbk)
    for i in range(Lx): bkdot[i]=bkdot[i]-mnbk
    bs=sorted(bkdot)
    nsec=0; XX1=[]; sec=[]
    for i in range(Lx-1):
        if(bkdot[i]==0 and bkdot[i+1]>0): 
            IX=i; 
            nsec+=1; XX1.append(IX)
            #print('nsec=',nsec,i,bkdot[i:i+3])
            cv2.line(im1,(IX,0),(IX,Ly-1),(0,0,0),2)
    #print('nsec_XX1=',nsec,XX1)
    XX2=XX1.copy()
    if(nsec>2): DX=int((XX1[2]-XX1[0])/2*0.6)
    else: DX=0
    #print('DX=',DX)
    #input('1111')
    if(nsec>2):
        for i in range(1,nsec):
            if((XX1[i]-XX1[i-1])<DX):
                XX2.pop(i); break
        nsec=len(XX2)
    #print('nsec=',nsec,'XX2=',XX2)
    #cv2.imshow('vim1',im1)    
    imgvl=np.copy(im1)
    NUM=[]
    for j in range(nsec-1):
        imgj=imgX[:,XX2[j]:XX2[j+1],:]
        #cv2.imshow('imgj_'+str(j),imgj)
        NUM.append(imgj)
    #cv2.waitKey(0)
    return NUM,imgvl


def CNTRG(img):
    cv2.imshow('CNTR_img',img)
    Lx=img.shape[1]; Ly=img.shape[0]; YC=int(Ly/2); XC=int(Lx/2)
    img1=np.copy(img)
    im1=np.copy(img)
    imp=np.copy(img)
    if(img.shape[0]<5 or img.shape[1]<5): return img,[],[]
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    H10,L10=highlow(hsv,YC); HC=H10-60
    avL,avH=HLA(hsv)
    if(Ly<60):
        HC=int(avL*0.9)
    else:
        HC=int(avL*1.5)
    print('av:',avL,avH,Lx,Ly,Lx*Ly,' HC=',HC)
    gray=cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    ret,bina=cv2.threshold(gray, HC, 255, cv2.THRESH_BINARY)     
    #cv2.imshow('bina1',bina); cv2.waitKey(0); 
    #............................................... AN3 1st bina with HC
    cnts2,_ = cv2.findContours(bina.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #...............................................
    lencnt2=len(cnts2)
    gr4=np.copy(bina)
    gr5=np.copy(bina)
    Lx4=int(Lx*0.4)
    #print('CNTR_lencnt2=',lencnt2,gr4.shape,'Lx4=',Lx4)
    DXC=int(Lx/10); DYC=int(Ly*0.4); DXC1=DXC*5; DXC2=DXC*0.5; arc=100
    #print('DXC,DYC,DXC1,DXC2=',DXC,DYC,DXC1,DXC2,' arc=',arc)
    N4=0; NC4=0; data4=[]; shp=[]; PX1=Lx; PX2=0; P1=[]; P2=[]; NUMA=[]
    for C in cnts2: 
        shp.append(C.shape)
        NC4+=1
        (a,b,c,d)=cv2.boundingRect(C); 
        ar=c*d; asp2=round(d/c,2)
        #print(NC4,(a,b,c,d,ar),(c,DXC1,DXC2),(d,DYC))
        if(ar<arc): continue
        if(c>DXC1 or c<DXC2): continue 
        if(d<DYC): continue 
        if(N4==0): H1=d
        N4+=1
        data4.append([a,b,c,d,ar])
        #print(NC4,'cnts2_N4=',N4,(a,b,c,d,ar))
        cv2.rectangle(gr5,(a,b),(a+c,b+d),50,2)
        nump=gr5[b:b+d,a:a+c]
        NUMA.append(nump)
        #cv2.imshow('gr5',gr5); cv2.waitKey(0)
        if(a<PX1): PX1=a; P1=[b,c,d]
        if(a>PX2): PX2=a; P2=[b,c,d]
        #cv2.rectangle(img4,(a-5,b-5),(a+c+5,b+d+5),(255,125,0),20)
    LN4=len(data4); print('CNTR_N4=',N4,' LN4=',LN4)
    #for t in range(LN4):
    #    print(t,data4[t])
    #print('Px1,P1=',PX1,P1)
    #print('Px2,P2=',PX2,P2)
    #cv2.imshow('gr5',gr5); cv2.waitKey(0)
    return LN4,data4,NUMA,gr5,PX1,P1,PX2,P2





def CNTR(img):
    cv2.imshow('CNTR_img',img)
    Lx=img.shape[1]; Ly=img.shape[0]; YC=int(Ly/2); XC=int(Lx/2)
    img1=np.copy(img)
    im1=np.copy(img)
    imp=np.copy(img)
    if(img.shape[0]<5 or img.shape[1]<5): return img,[],[]
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    H10,L10=highlow(hsv,YC); HC=H10-60
    avL,avH=HLA(hsv)
    if(Ly<60):
        HC=int(avL*0.9)
    else:
        HC=int(avL*1.5)
    print('av:',avL,avH,Lx,Ly,Lx*Ly,' HC=',HC)
    gray=cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    ret,bina=cv2.threshold(gray, HC, 255, cv2.THRESH_BINARY)     
    #cv2.imshow('bina1',bina); cv2.waitKey(0); 
    #............................................... AN3 1st bina with HC
    cnts2,_ = cv2.findContours(bina.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #...............................................
    lencnt2=len(cnts2)
    gr4=np.copy(bina)
    gr5=np.copy(bina)
    Lx4=int(Lx*0.4)
    #print('CNTR_lencnt2=',lencnt2,gr4.shape,'Lx4=',Lx4)
    DXC=int(Lx/10); DYC=int(Ly*0.4); DXC1=DXC*5; DXC2=DXC*0.5; arc=100
    #print('DXC,DYC,DXC1,DXC2=',DXC,DYC,DXC1,DXC2,' arc=',arc)
    N4=0; NC4=0; data4=[]; shp=[]; PX1=Lx; PX2=0; P1=[]; P2=[]; NUMA=[]
    for C in cnts2: 
        shp.append(C.shape)
        NC4+=1
        (a,b,c,d)=cv2.boundingRect(C); 
        ar=c*d; asp2=round(d/c,2)
        #print(NC4,(a,b,c,d,ar),(c,DXC1,DXC2),(d,DYC))
        if(ar<arc): continue
        if(c>DXC1 or c<DXC2): continue 
        if(d<DYC): continue 
        if(N4==0): H1=d
        N4+=1
        data4.append([a,b,c,d,ar])
        #print(NC4,'cnts2_N4=',N4,(a,b,c,d,ar))
        cv2.rectangle(gr5,(a,b),(a+c,b+d),50,2)
        nump=gr5[b:b+d,a:a+c]
        NUMA.append(nump)
        #cv2.imshow('gr5',gr5); cv2.waitKey(0)
        if(a<PX1): PX1=a; P1=[b,c,d]
        if(a>PX2): PX2=a; P2=[b,c,d]
        #cv2.rectangle(img4,(a-5,b-5),(a+c+5,b+d+5),(255,125,0),20)
    LN4=len(data4); print('CNTR_N4=',N4,' LN4=',LN4)
    #for t in range(LN4):
    #    print(t,data4[t])
    #print('Px1,P1=',PX1,P1)
    #print('Px2,P2=',PX2,P2)
    #cv2.imshow('gr5',gr5); cv2.waitKey(0)
    return LN4,data4,NUMA,gr5,PX1,P1,PX2,P2










def AN3(img):
    Lx=img.shape[1]; Ly=img.shape[0]; YC=int(Ly/2); XC=int(Lx/2)
    img1=np.copy(img)
    im1=np.copy(img)
    imp=np.copy(img)
    LN4,data4,NUMA,gr5,PX1,P1,PX2,P2=CNTR(img1)
    cv2.imshow('gr5',gr5)
    print('AN3_img1.shape=',img1.shape,' LN4=',LN4)
    for t in range(LN4):
        print('NUMt=',t,data4[t])
        cv2.imshow('AN3_N_'+str(t).zfill(2),NUMA[t])
    cv2.waitKey(0)
    return img,data4,NUMA

    if(img.shape[0]<5 or img.shape[1]<5): return img,[],[]
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    H10,L10=highlow(hsv,YC); HC=H10-60
    avL,avH=HLA(hsv)
    HC=int(avL*1.5)
    #H10,L10=high10(hsv,Y); D10=H10-L10; DCX=int(D10*0.8)
    print('H10,L10=',H10,L10,'HC=',HC)
    gray=cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    ret,bina=cv2.threshold(gray, HC, 255, cv2.THRESH_BINARY)     
    #bina=np.copy(gray)
    cv2.imshow('bina1',bina); cv2.waitKey(0); 
    #............................................... AN3 1st bina with HC
    cnts2,_ = cv2.findContours(bina.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #...............................................
    lencnt2=len(cnts2)
    gr4=np.copy(bina)
    gr5=np.copy(bina)
    Lx4=int(Lx*0.4)
    print('AN3_cnts2=',lencnt2,gr4.shape,'Lx4=',Lx4)
    DXC=int(Lx/10); DYC=int(Ly*0.8); DXC1=DXC*0.5; DXC2=DXC/2
    N4=0; NC4=0; data4=[]; shp=[]; PX1=Lx; PX2=0; P1=[]; P2=[]
    for C in cnts2: 
        shp.append(C.shape)
        NC4+=1
        (a,b,c,d)=cv2.boundingRect(C); 
        ar=c*d; asp2=round(d/c,2)
        print(NC4,(a,b,c,d,ar),c,Lx4)
        if(ar<100): continue
        if(c>Lx4): continue
        if(c>DXC1 or c<DXC2): continue 
        if(d<DYC*0.5): continue 
        if(N4==0): H1=d
        N4+=1
        data4.append([a,b,c,d,ar])
        print(NC4,'cnts2_N4=',N4,(a,b,c,d,ar))
        cv2.rectangle(gr5,(a,b),(a+c,b+d),50,2)
        #cv2.imshow('gr5',gr5); cv2.waitKey(0)
        if(a<PX1): PX1=a; P1=[b,c,d]
        if(a>PX2): PX2=a; P2=[b,c,d]
        #cv2.rectangle(img4,(a-5,b-5),(a+c+5,b+d+5),(255,125,0),20)
    LN4=len(data4); print('N4=',N4,' LN4=',LN4)
    for t in range(LN4):
        print(t,data4[t])
    print('Px1,P1=',PX1,P1)
    print('Px2,P2=',PX2,P2)
    cv2.imshow('gr5',gr5); cv2.waitKey(0)
    KTIL=1
    if(len(P1)==0): print('len(P1) zero:'); imgTL=np.copy(img); KTIL=0
    if(len(P2)==0): print('len(P2) zero:'); imgTL=np.copy(img); KTIL=0
    #========================TILT&TWIST operation=====================
    if(KTIL==1):
        p1=(PX1,P1[0]); p2=(PX1,P1[0]+P1[2]); 
        x1=PX1; y1=P1[0]; w1=P1[1]; h1=P1[2]
        SW=[]; Nj=0
        for j in range(y1+5,y1+h1-5):
            Nj+=1
            for i in range(x1-2,x1+w1-2):
                if(i<0): continue
                if(bina[j,i]>100 and bina[j,i+1]<100 and bina[j,i+2]<100): 
                    if(len(SW)>1 and Nj>3 and i>SW[-1][0]+5): 
                        #print('jump:',j,i,SW[-1]); 
                        continue
                    cv2.circle(gr4,(i,j),2,125,-1)
                    SW.append([i,j]); break
        LSW=len(SW); LSW2=int(LSW/2)
        print('AN3_LSW=',LSW)
        if(LSW<1 or LSW2<1):
            print('LSW=',LSW,LSW2,len(P1),len(P2))
            return img,[],[]
            #input('LLLLL')
        yy=np.array(SW); yy2=yy[0:LSW2,0].astype(int); LT=int(np.average(yy2))
        p1=[LT,SW[0][1]]; p2=SW[-1]; p3=(PX2+P2[1],P2[0]+5)
        q1=p1; q2=(p1[0],p2[1]); q3=(p3[0],p1[1])
        pts1=np.float32([p1,p2,p3])
        pts2=np.float32([q1,q2,q3])
        M=cv2.getAffineTransform(pts1,pts2)
        rows,cols,ch = img.shape
        co2=int(cols*1.0); ro2=int(rows*1.0)
        imgTL=cv2.warpAffine(img,M,(co2,ro2)) 
        print('p1,2,3=',p1,p2,p3,' P1,2=',(PX1,P1),(PX2,P2))
        cv2.circle(imp,p1,8,(0,0,255),-1)
        cv2.circle(imp,p2,8,(0,0,255),-1)
        cv2.circle(imp,p3,8,(0,0,255),-1)
        cv2.imshow('gr4_AN3',gr4)
        cv2.imshow('gr5_AN3',gr5)
        cv2.imshow('imp_AN3',imp)
        cv2.imshow('imgTL_AN3',imgTL)
        cv2.waitKey(0)



    #==========================================  NUMBER contours/bina with HC
    gray=cv2.cvtColor(imgTL, cv2.COLOR_BGR2GRAY)
    ret,bina=cv2.threshold(gray, HC, 255, cv2.THRESH_BINARY)     
    cv2.imshow('binaTL',bina); #cv2.waitKey(0); 
    #.....................................................AN3 2nd contour
    cnts2,_ = cv2.findContours(bina.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #.......................................................
    lencnt2=len(cnts2)
    gr4=np.copy(bina)
    gr5=np.copy(bina)
    #print('AN3_cnts2=',lencnt2,gr4.shape,'Lx*0.4=',int(Lx*0.4))
    N4=0; NC4=0; data4=[]; NUM=[]; XN=[]
    for C in cnts2: 
        NC4+=1
        (a,b,c,d)=cv2.boundingRect(C); 
        ar=c*d; asp2=round(d/c,2)
        #print(NC4,(a,b,c,d,ar))
        if(ar<200 or d<Ly*0.3): continue
        if(c>Lx*0.4): continue
        N4+=1
        data4.append([a,b,c,d,ar]); XN.append(a)
        #print('TL_N4=',N4,(a,b,c,d,ar))
        cv2.rectangle(gr5,(a,b),(a+c,b+d),50,2)
        E=2
        numc=gr4[b-E:b+d+E,a-E:a+c+E]
        NUM.append(numc)
    XS=sorted(XN); NUM2=[]
    for i in range(len(XS)):
        k=XN.index(XS[i])
        #print(i,k,XS[i],data4[k][0])
        NUM2.append(NUM[k])
    #input('KKKK')
    cv2.imshow('TL_gr5',gr5); 
    cv2.waitKey(0)


    return imgTL,data4,NUM2
        







#----------------------BLKBLK-------
def WboxBLK(image):
    #---------------------------- white color----------
    low=np.array([0,0 ,190 ])
    upp=np.array([255,30 ,255 ])
    low2=np.array([0,0 ,0 ])
    upp2=np.array([255,255 ,60 ])
    im=np.copy(image); imgb=np.copy(im)
    Lx=im.shape[1]; Ly=im.shape[0]; Lxs=int(Lx/4); Lys=int(Ly/4);
    Lx2=int(Lx/2); Ly2=int(Ly/2); YC=Ly2
    img=np.copy(im);img1=np.copy(img);img2=np.copy(im);imgF=np.copy(im);imgT=np.copy(im)
    X1=img.shape[1];Y1=img.shape[0];X2=int(X1/4); Y2=int(Y1/4)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    imgrs=cv2.resize(img,(int(Lx/10),int(Ly/10)))
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsvrs)
    H10,L10=highlow(hsv,YC); HC=H10; BLK=HC-50; BLK=50; WHITE=int(avH*0.8)
    if(WHITE<165): print('low white,original_white=',WHITE); #WHITE=165
    #print('H10,L10=',H10,L10,'HC=',HC,'BLK=',BLK,'avH,L,WHITE=',avH,avL,WHITE)
    #input('1111')
    #----------------------------- mask on black
    low1=np.array([0,80 ,0])
    upp1=np.array([255,255 ,210])
    low2=np.array([0,0 ,0 ])
    upp2=np.array([255,255 ,WHITE])
    lowT=np.array([0,0 ,180])
    lowT=np.array([0,0 ,WHITE])
    uppT=np.array([255,120 ,255])
    #-----------------------------
    maskT=cv2.inRange(hsv,lowT,uppT)
    mask1=cv2.inRange(hsv,low1,upp1)
    mask2=cv2.inRange(hsv,low2,upp2)
    mask3=mask1 | mask2
    mask3=maskT
    imC=cv2.bitwise_and(img,img,mask=mask3)
    imCs=cv2.resize(imC,(X2,Y2))
    #cv2.imshow('imCs',imCs)
    mask1s=cv2.resize(mask1,(X2,Y2))
    mask2s=cv2.resize(mask2,(X2,Y2))
    mask3s=cv2.resize(mask3,(X2,Y2))
    gr=np.copy(mask3);gr1=np.copy(mask3);
    gr2=np.copy(mask3);
    gr3=np.copy(mask3);gr3[:,:]=255
    gr6=np.copy(mask3);gr6[:,:]=255; gr7=np.copy(gr6)
    #cv2.imshow('mask3s',mask3s)
    gr2s=cv2.resize(gr2,(X2,Y2))
    #cv2.imshow('gr2s',gr2s)
    #cv2.waitKey(0)

    #..........................................................WboxBLK 1st Contour
    cnts1,_ = cv2.findContours(gr2.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #..........................................................
    Nc=0; Nac=0; box=[]; data1=[]; NCU=0; NCUY=0; IMGSA=[]; IMGS6=[]; IMGS7=[]; PLAT=[]; 
    for c in cnts1: 
        Nc+=1
        M=cv2.moments(c)
        if(M['m00']==0): M['m00']=1
        cX=int(M['m10']/M['m00']); cY=int(M['m01']/M['m00'])
        area=int(cv2.contourArea(c));
        (x,y,w,h)=cv2.boundingRect(c); 
        xx1=(x,y,w,h); mx1=(cX,cY); xxa=(x,y,w,h)
        Ac=w*h; asp=round(h/w,2); ratA=round(area/Ac,3); aspx=1.*asp
        imgc=img1[y:y+h,x:x+w,:]
        if(h<30 or w<90): continue
        if(Ac<1000): continue
        if(w>700): continue
        DBW,avH,avL,Dav=DBKWT(imgc)
        if(DBW==0): continue

        if(asp<0.1): continue
        elif(0.1<=asp<0.6): 
            KHL=1; NHL=100
            KC,NSW=censcan(imgc); RSW=round(NSW/w,2)
            if(KC==0 or NSW<3 or RSW<0.01): continue
        elif(asp>=0.6):
            KC,NSW=censcan(imgc); RSW=round(NSW/w,2)
            KHL,NHL,YA,YB=SCHL(imgc)
            if(KHL==0): continue
            y=y+YA; h=YB-YA
            xx1=(x,y,w,h); mx1=(cX,cY)
            Ac=w*h; asp=round(h/w,2); ratA=round(area/Ac,3)
            #print('xxa,xxb=',xxa,xx1)
        xxb=(x,y,w,h)
        if(h<80):
            if(y>10): y-=10; h+=20
            if(x>20): x-=20; w+=40 
        xx1=(x,y,w,h); Ac=w*h; asp=round(h/w,2); ratA=round(area/Ac,3); 
        grc=gr1[y-5:y+h+5,x-5:x+w+5]
        grd=img[y-5:y+h+5,x-5:x+w+5]
        if(w>500 or h>250 ): 
            #print('large pic:',w,h,grd.shape); 
            #if(grd.shape[0]>8 and grd.shape[1]>8):cv2.imshow('L',grd);cv2.waitKey(0)
            continue
        if(grc.shape[0]==0 or grc.shape[1]==0): continue
        Nac+=1
        #print(Nac,Nc,xx1,xxb,(Ac,asp),(DBW,avH,avL,Dav),(KC,NSW),(KHL,NHL))
        #cv2.rectangle(gr2,(x,y),(x+w,y+h),125,15)
        cv2.rectangle(imgb,(x,y),(x+w,y+h),(255,75,0),20)
        data1.append(xx1)
        PLAT.append(grd)
    gr2s=cv2.resize(gr2,(X2,Y2))
    PLAT.insert(0,imgb)
    data1.insert(0,Nac)
    #cv2.imshow('gr2s',gr2s)
    imgbs=cv2.resize(imgb,(X2,Y2))
    #cv2.imshow('imgb',imgbs)
    #print('Nac=',Nac,Nc)
    #cv2.waitKey(0)
    return Nac,data1,PLAT









#----------------------BLKBLK-------
def XWboxBLK(image):
    #---------------------------- white color----------
    low=np.array([0,0 ,190 ])
    upp=np.array([255,30 ,255 ])
    low2=np.array([0,0 ,0 ])
    upp2=np.array([255,255 ,60 ])
    im=np.copy(image); imgb=np.copy(im)
    Lx=im.shape[1]; Ly=im.shape[0]; Lxs=int(Lx/4); Lys=int(Ly/4);
    Lx2=int(Lx/2); Ly2=int(Ly/2); YC=Ly2
    img=np.copy(im);img1=np.copy(img);img2=np.copy(im);imgF=np.copy(im);imgT=np.copy(im)
    X1=img.shape[1];Y1=img.shape[0];X2=int(X1/4); Y2=int(Y1/4)
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    imgrs=cv2.resize(img,(int(Lx/10),int(Ly/10)))
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsvrs)
    H10,L10=highlow(hsv,YC); HC=H10; BLK=HC-50; BLK=50; WHITE=int(avH*0.8)
    print('H10,L10=',H10,L10,'HC=',HC,'BLK=',BLK,'avH,WHITE=',avH,H10,WHITE)
    #input('1111')
    #----------------------------- mask on black
    low=np.array([0,80 ,0])
    upp=np.array([255,255 ,210])
    low2=np.array([0,0 ,0 ])
    upp2=np.array([255,255 ,WHITE])
    #-----------------------------
    mask1=cv2.inRange(hsv,low,upp)
    mask2=cv2.inRange(hsv,low2,upp2)
    mask3=mask1 | mask2
    mask3=mask2
    ret,bina=cv2.threshold(mask3, HC, 255, cv2.THRESH_BINARY)     
    imgmask=cv2.bitwise_and(img,img,mask=mask3)
    img3=np.copy(imgmask)
    img3s=cv2.resize(img3,(X2,Y2))
    mask1s=cv2.resize(mask1,(X2,Y2))
    mask2s=cv2.resize(mask2,(X2,Y2))
    mask3s=cv2.resize(mask3,(X2,Y2))
    gr=np.copy(bina);gr1=np.copy(bina);gr2=np.copy(bina);
    gr3=np.copy(bina);gr3[:,:]=255
    gr6=np.copy(bina);gr6[:,:]=255; gr7=np.copy(gr6)
    mask1=np.copy(gr3); mask1[:,:]=0
    img2=np.copy(img1); img4=np.copy(img1)
    binas=cv2.resize(bina,(X2,Y2))
    gr2s=cv2.resize(gr2,(X2,Y2))
    bina2=np.copy(bina)
    #cv2.imshow('mask3s',mask3s)
    #cv2.imshow('binas',binas)
    cv2.imshow('gr2s',gr2s)
    #cv2.waitKey(0)
    #  gr2 has white plate as black rect for contour
    #..........................................................WboxBLK 1st Contour
    cnts1,_ = cv2.findContours(gr2.copy(), cv2.RETR_LIST,
          cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
    #..........................................................
    print('1st contour:len=',len(cnts1))
    Nc=0; Nac=0; box=[]; data1=[]; NCU=0; NCUY=0; IMGSA=[]; IMGS6=[]; IMGS7=[]
    for c in cnts1: 
        NCU+=1
        M=cv2.moments(c)
        if(M['m00']==0): M['m00']=1
        cX=int(M['m10']/M['m00']); cY=int(M['m01']/M['m00'])
        area=int(cv2.contourArea(c));
        (x,y,w,h)=cv2.boundingRect(c); 
        xx1=(x,y,w,h); mx1=(cX,cY)
        Ac=w*h; asp=round(h/w,2); ratA=round(area/Ac,3)
        imgc=img1[y:y+h,x:x+w,:]
        if(h<30 or w<90): continue
        if(w<10 or h<5): continue
        if(Ac<1000): continue
        if(asp>1.8 or asp<0.1): continue
        DBW,avH,avL,Dav=DBKWT(imgc)
        KC,NSW=censcan(imgc) 
        #if(h>250): print('DBW..=',DBW,avH,avL,Dav,xx1,KC,NSW)
        if(DBW==0): continue
        RSW=round(NSW/w,2)
        #print('Nc=',Nc,Nac,KC,NSW,RSW)
        if(w>700): continue
        #if(KC==0 or NSW<3 or RSW<0.01): continue
        if(h>2 and Lx*0.4<w<Lx*0.8): 
            print('Lgrc=',grc.shape,xx1,(Nbd,ratbd),Ac,asp)
            cv2.rectangle(bina2,(x,y),(x+w,y+h),0,15)
            cv2.rectangle(imgb,(x,y),(x+w,y+h),(255,125,0),15)
            bin2s=cv2.resize(bina2,(X2,Y2))
            cv2.imshow('bin2s',bin2s)
            cv2.imshow('Lgrc',grc); 
            cv2.waitKey(0); 
            #continue
        grc=gr1[y-5:y+h+5,x-5:x+w+5]
        grd=img[y-5:y+h+5,x-5:x+w+5]
        if(grc.shape[0]==0 or grc.shape[1]==0): continue
        Nc+=1
        NCUY+=1
        #print('grc.shape=',grc.shape,xx1)
        #..........verify the box border is white.....
        NBK=0; NS=0; 
        y1=int(grc.shape[0]*0.2); y2=int(grc.shape[0]*0.8)
        x1=int(grc.shape[1]*0.2); x2=int(grc.shape[1]*0.8)
        x1a=x1;x2a=x2;y1a=y1;y2a=y2
        for i in range(x1,x2):
            NBK+=int(grc[y1*2,i]/255)
            NBK+=int(grc[y1*3,i]/255)
        Nbd=2*(x2-x1)+2*(y2-y1)
        ratbd=round(NBK/Nbd,2)
        if(ratbd>0.45 or ratbd<0.03): continue
        #KC,NSW=censcan(grd) 
        #if(KC==0): continue
        cv2.imshow('grd',grd)
        #cv2.imshow('grc',grc)
        cv2.rectangle(bina2,(x,y),(x+w,y+h),0,15)
        cv2.rectangle(imgb,(x,y),(x+w,y+h),(255,125,0),15)
        IMGSA.append(grd)
        Nac+=1
        print('Nac=',Nac,'1st_=',xx1,(NBK,Nbd,ratbd),Ac,asp,'RSW=',RSW,NSW)
        bin2s=cv2.resize(bina2,(X2,Y2))
        imgbs=cv2.resize(imgb,(X2,Y2))
        cv2.imshow('imgbs',imgbs)
        cv2.imshow('bin2s',bin2s)
        if(w>600): cv2.waitKey(0)
        continue


        # grd is one of the white plates found in gr2.....
        #====================check grd plate...
        imp5=np.copy(grd); YC=int(imp5.shape[0]/2)
        cv2.imshow('imp5',imp5); #cv2.waitKey(0)
        hsv=cv2.cvtColor(imp5,cv2.COLOR_BGR2HSV)
        H10,L10=highlow(hsv,YC); HC=H10; BLK=HC-50; BLK=50; WHITE=int(avH*0.8)
        print('H10,L10=',H10,L10,'HC=',HC,'BLK=',BLK,'avH,WHITE=',avH,WHITE)
        #L10,H10=HLA(hsv)
        #H10,L10=highlow(hsv,YC); HC=int(H10*1.0); D10=H10-L10
        #print(imp5.shape,H10,L10,D10)
        low3=np.array([0,0 ,0 ])
        upp3=np.array([255,255 ,WHITE])
        mask3=cv2.inRange(hsv,low3,upp3)
        cv2.imshow('MASK3',mask3)
        ret,bina=cv2.threshold(mask3, HC, 255, cv2.THRESH_BINARY)     
        bina=np.copy(mask3)
        #cv2.imshow('BINA',bina)
        print('6_bina.shape=',bina.shape,' compare imp5,mask3,bina...')
        cv2.waitKey(0)
        gray5=np.copy(bina)
        gray5=np.copy(mask3)
        #--------------------------------------------------------------
        cntsb,_ = cv2.findContours(gray5.copy(), cv2.RETR_LIST,
              cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
        #--------------------------------------------------------------
        gr5=np.copy(grc); ry=gr5.shape[0]; rx=gr5.shape[1]; #print('gr5.shape=',gr5.shape)
        cntsb2,_ = cv2.findContours(grc.copy(), cv2.RETR_LIST,
              cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
        #..............................................................
        #print('lenb=',len(cntsb))
        NR=0; NR1=0
        for r in cntsb:
            NR1+=1
            area2=int(cv2.contourArea(r));
            (x2,y2,w2,h2)=cv2.boundingRect(r); 
            Ac2=w2*h2; asp2=round(h2/w2,2); ratA2=round(area2/Ac2,3)
            grd2=img[y2-5:y2+h2+5,x2-5:x2+w2+5]
            if(grd2.shape[0]<2 or grd2.shape[1]<2): continue
            #print(NR1,'grd2.shape=',grd2.shape)
            #KC,NSW=censcan(grd2) 
            #if(KC==0): continue
            #print(NR1,xx2,Ac2,asp2,0.5*ry,0.5*rx)
            if(h2>0.1*ry and w2<0.5*rx):
                NR+=1; #print('cntsb_NR=',NR)
                cv2.rectangle(gr5,(x2,y2),(x2+w2,y2+h2),125,5)
                cv2.rectangle(gr6,(x+x2-10,y+y2-2),(x+x2+w2+10,y+y2+h2+2),0,2)
                cv2.rectangle(imp5,(x2,y2),(x2+w2,y2+h2),(255,125,),5)
        #print('6NR=',NR)
        cv2.imshow('imp5',imp5)
        cv2.imshow('gray5',gray5)
        cv2.imshow('gr5',gr5)
        gr6s=cv2.resize(gr6,(X2,Y2))
        cv2.imshow('gr6s',gr6s)
        IMGS6.append(grd2)
        print('6NCU,Y=',NCU,NCUY,'gr6 done.....TOTAL_cntsB=',NR,len(IMGSA),len(IMGS6))
        cv2.waitKey(0)
        continue





        
        cntsc,_ = cv2.findContours(gr6.copy(), cv2.RETR_LIST,
              cv2.CHAIN_APPROX_SIMPLE) # cv2.RETR_LIST, EXTERNAL
        NR=0; data7=[]; NPLT7=0; 
        for r in cntsc:
            NR1+=1
            M2=cv2.moments(r)
            if(M2['m00']==0): M2['m00']=1
            cX2=int(M2['m10']/M2['m00']); cY2=int(M2['m01']/M2['m00'])
            xx2=(x2,y2,w2,h2); mx2=(cX,cY)
            ar2=int(cv2.contourArea(r));
            (x2,y2,w2,h2)=cv2.boundingRect(r); 
            xx2=[x2,y2,w2,h2]; mx2=(cX2,cY2)
            EX7=10; EY7=5
            xx3=[x2-EX7,y2-EY7,w2+EX7,h2+EY7]; 
            Ac2=w2*h2; asp2=round(h2/w2,2); ratA2=round(area2/Ac2,3)
            grd2=img[y2-5:y2+h2+5,x2-5:x2+w2+5]
            if(grd2.shape[0]<2 or grd2.shape[1]<2): continue
            #print(NR1,'grd2.shape=',grd2.shape)
            #KC,NSW=censcan(grd2) 
            #if(KC==0): continue
            if(asp2<0.2 or asp2>0.8): continue
            if(100<w2<500):
                NPLT7+=1; NR+=1; #print(y2,xx2,' plot gr7 rect')
                #print('CNTSC_NR=',NR,xx2,Ac2,asp2,ar2,' plot gr7 rect,NPLT7=',NPLT7)
                #cv2.rectangle(gr5,(x2,y2),(x2+w2,y2+h2),125,5)
                cv2.rectangle(gr7,(x2-1,y2-1),(x2+w2+1,y2+h2+1),0,2)
                #cv2.rectangle(imp5,(x2,y2),(x2+w2,y2+h2),(255,125,),5)
                gr7s=cv2.resize(gr7,(X2,Y2))
                cv2.imshow('gr7s',gr7s)
                data7.append((xx3,mx2,Ac2,ar2,asp2,ratA2))
        '''
        print('7NCU,Y=',NCU,NCUY,'total_cntsC_NR=',NR)
        #cv2.imshow('imp5',imp5)
        #cv2.imshow('gray5',gray5)
        #cv2.imshow('gr5',gr5)
        gr7s=cv2.resize(gr7,(X2,Y2))
        cv2.imshow('gr7s',gr7s)
        len7=len(data7)
        #print('len7=',len7)
        '''

    '''
    #cv2.waitKey(0)
    #cv2.destroyAllWindows();
    print('1st_Nac=',Nac,' lenbox=',len(box))
    print('len7=',len7)
    for k in range(len7):
        x71=data7[k][0][0];
        y71=data7[k][0][1];
        w71=data7[k][0][2];
        h71=data7[k][0][3];
        grc7=gr6[y71:y71+h71,x71:x71+w71]
        imgc7=img[y71:y71+h71,x71:x71+w71]
        #cv2.imshow('grc7_'+str(k),grc7)
        cv2.imshow('imgc7_'+str(k),imgc7)
    print('1st_grs done.....')
    cv2.waitKey(0)
    return len7,data7,gr7
    '''
    print('lenIMGSA,6=',len(IMGSA),len(IMGS6))
    #for t in range(len(IMGS)):
    #    cv2.imshow('IMGS_'+str(t),IMGS[t])
    cv2.waitKey(0)




def RUNAN3():
    NF=2
    for t in range(9):
        fn='PNG/LP2/LP_0'+str(t)+'.png'
        #fn='PNG/LP/LB_3_'+str(t)+'.png'
        print('t,fn=',t,fn)
        img1=cv2.imread(fn)
        #--------------------------
        #imgTL=AN3(imgc)
        #cv2.waitKey(0)
    print('---AN3 done---')
    #cv2.waitKey(0)


def readpic():
    NPIC=15; PIC=[]
    for i in range(NPIC):
        #s='plateYY/P'+str(i+1).zfill(1)+'.JPG'
        #s='plate01/P'+str(i+1).zfill(2)+'.jpg'
        s='plate02/P'+str(i+1).zfill(2)+'.JPG'
        #img0=cv2.imread(s)
        #print(s,img0.shape)
        PIC.append(s)
    return PIC


import os
def load_images_from_folder(folder):
    images = []
    for filename in os.listdir(folder):
        img = cv2.imread(os.path.join(folder,filename))
        if img is not None:
            images.append(img)
    return images


def readimg():
    folder='comp'
    IMGS=load_images_from_folder(folder)
    #print(type(IMGS),len(IMGS))
    return IMGS
    N=0
    for img in IMGS:
        N+=1
        LX=img.shape[1]; LX2=int(LX/8)
        LY=img.shape[0]; LY2=int(LY/8)
        imgs=cv2.resize(img,(LX2,LY2))
        print(N,img.shape,imgs.shape)
        cv2.imshow('img_'+str(N).zfill(2),imgs)
        if cv2.waitKey(2000) & 0xFF == ord('q'): break
    input('RRRR')




if __name__ == '__main__':
    from time import sleep
    import cv2
    import numpy as np
    #print('fcolor.py as a main')

    tm0=time.time()
    readimg()
    #input('RRRR')

    #PIC=readpic()
    IMGS=readimg()
    print(type(IMGS),len(IMGS))
    NPIC=len(IMGS)
    low=np.array([10,0 ,150 ])
    upp=np.array([250,40 ,255 ])
    AVLH=[]
    for j in range(NPIC):
        PJ=j
        imgi=IMGS[j]
        Ly=imgi.shape[0]; Lx=imgi.shape[1]; Lx2=int(Lx/10); Ly2=int(Ly/10)
        imgs=cv2.resize(imgi,(Lx2,Ly2))
        hsv=cv2.cvtColor(imgs,cv2.COLOR_BGR2HSV)
        avL,avH=HLA(hsv)
        AVLH.append((avL,avH))
        print('j,shape=',j,imgi.shape,[Lx2,Ly2],imgs.shape,avL,avH)
        #cv2.imshow('imgs_'+str(j),imgs)
    #cv2.waitKey(0)
    #cv2.destroyAllWindows();
    #input('ppppp')



    #-------------------PPPPPPP
    tm1=time.time()
    for j in range(NPIC):
    #for j in range(1,2):
        PJ=j
        #ret,img=cap.read()
        #fn=PIC[j];imgi0=cv2.imread(fn);
        fn='PLATE/plate_C2_'+str(j).zfill(2)
        imgi0=IMGS[j]
        avL=AVLH[j][0]; avH=AVLH[j][1]
        #print('j,fn,shape=',j,fn,imgi0.shape)
        imgi=np.copy(imgi0);img1=np.copy(imgi0)
        imgs=cv2.resize(imgi,(Lx2,Ly2))
        Ly=imgi.shape[0]; Lx=imgi.shape[1]
        #cv2.imshow('imgs',imgs)
        #print('Lx,y=',Lx,Ly,imgi.shape,imgs.shape)
        if(Ly>3000):
            img1=imgi[int(Ly*0.2):int(Ly*0.7),:,:]
            img1=imgi[1200:1900,1100:3500,:]
            img1=imgi[1200:2400,100:3600,:]  # shaping in size (1200,3500)
            imgi=np.copy(img1)
        else:
            img1=imgi[int(Ly*0.2):,:,:]  # remove the farrest image
            imgi=np.copy(img1)
        #print('reshape imgi:',imgi.shape,img1.shape)
        #if(Ly<1200): img1=imgi[600:1100,:,:]; imgi=np.copy(img1)
        Lx=imgi.shape[1]; Ly=imgi.shape[0]; Lxs=int(Lx/4); Lys=int(Ly/4);
        X1=img1.shape[1];Y1=img1.shape[0];X2=int(X1/4); Y2=int(Y1/4)
        #print('\nf,fn=',j,fn,'imgi.shape=',imgi.shape,'Lxs,Lys=',Lxs,Lys)
        imgis=cv2.resize(imgi,(Lxs,Lys))
        #cv2.imshow('imgis',imgis)
        #cv2.waitKey(0)

        #============================================     WboxBLK
        #lenda2,data2,gr3=WboxBLK(imgi)
        Nac,data1,PLAT=WboxBLK(imgi)
        #============================================

        fnt=fn+'.png'
        cv2.imwrite(fnt,PLAT[0])
        #for t in range(1,Nac+1):
        #    cv2.imshow('plat_'+str(t).zfill(2),PLAT[t])
        print('j_file=',j,fn,Nac,data1[0:2])
        #print('back from Wbox in main, lenda2=',lenda2)
        #print('back from Wbox in main')
        #cv2.waitKey(0)
        #cv2.destroyAllWindows();
        #if(lenda2==0): continue
        #gr3s=cv2.resize(gr3,(Lxs,Lys))
        #cv2.imshow('gr3s',gr3s)
        #cv2.waitKey(0)
        continue



        img3=np.copy(imgi); img4=np.copy(imgi)
        print('***********back from WboxBLK with lenda2=',lenda2)
        TIMG=[]; NT=0
        for t in range(lenda2):
            NT+=1
            cv2.destroyAllWindows();
            (x,y,w,h)=data2[t][0]; (cx,cy)=data2[t][1]; 
            Ac,area,asp,ratA=data2[t][2:6]
            img4t=img4[y-5:y+h+5,x-5:x+w+5]
            cv2.rectangle(img3,(x-5,y-5),(x+w+5,y+h+5),(255,125,0),15)
            fnt='PNG/PLBK02/PLBK02_'+str(j).zfill(2)+'_'+str(t).zfill(2)+'.png'
            fn='PLBK_'+str(j).zfill(2)+'_'+str(t).zfill(2)
            fn2='TL'+str(j).zfill(2)+'_'+str(t).zfill(2)
            fn3='vl'+str(j).zfill(2)+'_'+str(t).zfill(2)
            print('\n\n**into AN3***t,fnt=',t,fnt[-12:-1],(x,y,w,h),Ac,area,asp,ratA)
            #==================================================== AN3 ======
            imgTL,data4,NUM=AN3(img4t); 
            #===============================================================
            #cv2.waitKey(0)
            cv2.destroyAllWindows();
            #cv2.imshow(fn2,imgTL)
            #cv2.imwrite(fnt,img4t); cv2.imshow(fn,img4t)
            #cv2.imwrite(fnt,imgTL); cv2.imshow(fn,imgTL)
            TIMG.append(imgTL); nt=0
            #for t in NUM: nt+=1; cv2.imshow('NUM_'+str(nt),t)
            print('NT=',NT,'aft AN3: nt=',nt,'lenNUM=',len(NUM),'TL.shp=',imgTL.shape)
            #NUM,imgvl=vscan(imgTL)
            #cv2.imshow(fn3,imgvl)
            #TIMG.append(imgvl)
            fn='PL_'+str(j).zfill(2)+'_'+str(NT)+'_'
            if(imgTL.shape[0]<5 or imgTL.shape[1]<5): continue
            cv2.imwrite('PNG13/'+fn+'0.png',imgTL); cv2.imshow(fn+'0',imgTL)
            if(len(NUM)==0): print('zero NUM'); continue
            print('ready to write NUMBERS...len(NUM)=',len(NUM))
            NI=0
            for t in NUM:
                NI+=1
                fim=fn+str(NI)
                fil='PNG13/'+fn+str(NI)+'.png'
                print(NI,fil,t.shape)
                if(t.shape[0]==0 or t.shape[1]==0): continue
                cv2.imwrite(fil,t); cv2.imshow(fim,t)
            #if cv2.waitKey(4) & 0xFF == ord('q'): break
            cv2.waitKey(0)
        cv2.destroyAllWindows();
        img3s=cv2.resize(img3,(Lxs,Lys))
        cv2.imshow('img3s',img3s)
        print('j,fn=',j,fn,' is done...')
        cv2.waitKey(0)
        #cv2.destroyAllWindows();
        cv2.destroyAllWindows();
tm2=time.time()
ttm0=round(tm1-tm0,3)
ttm=round(tm2-tm1,3)
print('ttm0=',ttm0,' ttm=',ttm)
#cv2.waitKey(0)
cv2.destroyAllWindows();
#cap.release()