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 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 CKHL(img):
    #cv2.imshow('CKHL_img',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
    imgrs=np.copy(img); SX=1
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    Lx2=hsvrs.shape[1]; Ly2=hsvrs.shape[0]
    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(j,Y,'LC=',LC,L10,H10,D10,'D0.7=',D10*0.5,'a=\n',a)
        #if(L10>100 or H10<180): continue
        if(D10<60): continue
        NSW=0; SW=[]; DHS=[]
        for i in range(Lx2-1):
            DH=abs(int(hsvrs[Y,i,2])-int(hsvrs[Y,i+1,2])); DHS.append(DH)
            if(DH>D10*0.5): NSW+=1; SW.append(i)
        #print('j,Y,NSW=',j,Y,NSW,' NHL=',NHL,'DHS=',DHS)
        if(NSW>4):
            NHL+=1
            #print('NSW>4: 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; 
    else: KHL=0
    #cv2.imshow('im1',im1)
    #cv2.waitKey(0)
    return KHL,NHL





def borderHL(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly; sx=int(Lx/4); sy=int(Ly/4)
    im1=np.copy(img)
    imgrs=cv2.resize(img,(sx,sy)); 
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    hsv=cv2.cvtColor(im1,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsvrs); WHITE=int(avH*0.6)
    YA1=0; YA2=Ly-1
    NY=80; YS=[int(Ly/NY*i) for i in range(NY)]; NHL=0; YHL=[]; Lxc=int(Lx*0.6)
    for j in range(NY):
        Y=YS[j]
        NW=0
        for i in range(Lx):
            if(hsv[Y,i,2]>WHITE): NW+=1
        if(NW>Lxc): 
            NHL+=1
            #print('NHL=',NHL,j,Y,NW)
            YHL.append((Y,NW))
            cv2.line(im1,(0,Y),(Lx,Y),(0,128,255),1)
            #cv2.imshow('im1',im1)
            #cv2.waitKey(0)
    #cv2.imshow('imHL',im1)
    NHL=len(YHL)
    if(NHL>1): YA1=YHL[0][0]; YA2=YHL[NHL-1][0]
    else: print('No horizontal Line: NHL=',NHL,' YA1,2=',YA1,YA2)
    #print('NHL=',NHL,' YA1,2=',YA1,YA2)
    #cv2.waitKey(0)
    return YA1,YA2,im1



def borderVL(rtw,img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly; sx=int(Lx/4); sy=int(Ly/4)
    im1=np.copy(img)
    #print('bVL,img.shape=',img.shape,' sx,sy=',sx,sy)
    imgrs=cv2.resize(img,(sx,sy)); 
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    hsv=cv2.cvtColor(im1,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsvrs); 
    #rtw=0.8; 
    WHITE=int(avH*rtw); #if too black, reduce rtw
    XA1=0; XA2=Lx-1
    NX=80; XS=[int(Lx/NX*i) for i in range(NX)]; NVL=0; XVL=[]; Lyc=int(Ly*rtw)
    for j in range(NX):
        X=XS[j]
        NW=0
        for i in range(Ly):
            if(hsv[i,X,2]>WHITE): NW+=1
        #print(j,X,NVL,NW,Lyc)
        if(NW>Lyc): 
            NVL+=1
            #print('NVL,j,X,NW=',NVL,j,X,NW)
            XVL.append((X,NW))
            cv2.line(im1,(X,0),(X,Ly),(255,128,0),1)
            #cv2.imshow('im1',im1)
            #cv2.waitKey(0)
    #cv2.imshow('imVL',im1)
    NVL=len(XVL)
    if(len(XVL)>1): XA1=XVL[0][0]; XA2=XVL[NVL-1][0]
    else: pass; #print('No vertical Line: NVL=',NVL,' XA1,2=',XA1,XA2)
    if(XA1>10): XA1-=10
    if(XA2<Lx-10): XA2+=10
    #cv2.waitKey(0)
    return XA1,XA2,im1







def SUBGR(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly
    F=4; imgrs=cv2.resize(img,(int(Lx/F),int(Ly/F))); 
    im1=np.copy(imgrs)
    XA1,XB1,YA1,YB1=scHL(im1)
    #print('SUBGR_XA1...=',XA1,XB1,YA1,YB1)
    XA=XA1*F; XB=XB1*F; YA=YA1*F; YB=YB1*F
    imgsub=img[YA:YB,XA:XB]
    #print('SUBGR_XA...=',XA,XB,YA,YB,' sub,1,g.shape=',imgsub.shape,im1.shape,img.shape)
    #cv2.imshow('SUB_img',img)
    #cv2.destroyAllWindows();
    #cv2.imshow('SUB_imgrs',imgrs)
    #if(imgsub.shape[0]>10 and imgsub.shape[1]>10): cv2.imshow('SUB_imgsub',imgsub)
    #cv2.waitKey(0)
    return imgsub,XA,XB,YA,YB



def SUB1(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly
    imgrs=cv2.resize(img,(int(Lx/4),int(Ly/4))); 
    im1 = cv2.blur(imgrs, (2, 2))
    im2=im1[:,:].astype(int); 
    A=imgrs.shape[0]*imgrs.shape[1]
    print('imgrs.shape=',imgrs.shape,' A=',A)
    cv2.imshow('img',img)
    cv2.imshow('imgrs',imgrs)
    cv2.imshow('im1',im1)
    Lx2=imgrs.shape[1]; Ly2=imgrs.shape[0]
    im3=np.full((Ly2,Lx2),255,dtype=np.uint8)
    a=np.copy(im2); aa=a.ravel(); sa=np.sort(aa);
    LB=int(len(sa)/10); blk=int(np.average(sa[0:LB]))+20
    print('sa=',sa[0:LB])
    print(A,LB,'blk=',blk)
    NB=0
    for i in range(Lx2):
        for j in range(Ly2):
            if(im1[j,i]<blk+50): print(NB,i,j,im1[j,i],blk)
            if(im1[j,i]<blk): im3[j,i]=0; NB+=1
    print(im3.shape,NB)
    #cv2.imshow('im3',im3)
    #cv2.waitKey(0)








def scHL(img):
    Lx=img.shape[1]; Ly=img.shape[0]; Yin1=0; Yin2=Ly; im1=np.copy(img)
    imgrs=np.copy(img); X1=0; X2=Lx; Y1=0; Y2=Ly
    hsvrs=cv2.cvtColor(imgrs,cv2.COLOR_BGR2HSV)
    Lx2=hsvrs.shape[1]; Ly2=hsvrs.shape[0]
    NY=40; 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
        if(D10<60): 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.8): NSW+=1; SW.append(i)
        #print(j,YS[j],' NHL=',NHL,NSW,' L10=',L10,H10,D10)
        if(NSW>8):
            NHL+=1
            #print('NSW>8: NSW=',NSW,j,Y,' NHL=',NHL,' SW=',SW)
            cv2.line(imgrs,(0,Y),(Lx2,Y),(255,0,0),2)
            cv2.line(im1,(0,Y),(Lx,Y),(255,0,0),1)
            YHL.append(Y)
    #cv2.imshow('imgrs_scHL',imgrs)
    if(NHL>0): 
        KHL=1; 
        if(NHL==1): 
            Y1=int(YHL[0]-YS[1]*3); Y2=Y1+int(2*YS[1]*3)
        else: Y1=int(YHL[0]-YS[1]*3); Y2=int(YHL[NHL-1]+2*YS[1]*3)
        #print('NHL=',NHL,' YHL=',YHL,' Y1,2=',Y1,Y2)
    else: KHL=0; Y1=YS[0]; Y2=YS[-1]
    if(Y2-Y1<10): return X1,X2,Y1,Y2
    im2=img[Y1:Y2,:]
    #cv2.imshow('im2',im2)
    #print('im2.shape=',im2.shape,' Y1,2=',Y1,Y2)
    rtwsc=0.8
    X1,X2,imx=borderVL(rtwsc,im2)
    im3=im2[:,X1:X2]
    #print('vL_X1,X2=',X1,X2,im2.shape,'im3.shape=',im3.shape,X1,X2)
    #cv2.imshow('im3_scHL',im3)
    #cv2.waitKey(0)
    return X1,X2,Y1,Y2








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]
    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 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)
    avL,avH=HLA(hsv); WHITE=int(avH*0.8)
    lowT=np.array([0,0 ,WHITE])
    uppT=np.array([255,120 ,255])
    maskT=cv2.inRange(hsv,lowT,uppT)
    mask3=maskT
    bina=np.copy(mask3)
    #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.2); 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)
        if(ar<arc): continue
        if(c>DXC1 or c<DXC2): continue 
        if(d<DYC): continue 
        if(N4==0): H1=d
        N4+=1
        #print(NC4,N4,(a,b,c,d,ar),(c,DXC1,DXC2),(d,DYC))
        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 RUNCNTR(img):
    img1=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



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)
    if(img.shape[0]<5 or img.shape[1]<5): return img,[],[]
    hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsv); WHITE=int(avH*0.8)
    lowT=np.array([0,0 ,WHITE])
    uppT=np.array([255,120 ,255])
    maskT=cv2.inRange(hsv,lowT,uppT)
    mask3=maskT
    bina=np.copy(mask3)

    #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)
    DXC=int(Lx/10); DYC=int(Ly*0.3); DXC1=DXC*5; DXC2=DXC/2; arc=100
    #print('AN3_cnts2=',lencnt2,gr4.shape,'Lx4=',Lx4,' DYC=',DYC)
    N4=0; NC4=0; data4=[]; shp=[]; PX1=Lx; PX2=0; P1=[]; P2=[]
    #------------------ use rectangle corners to find P1,P2 for p1,2,3 & q1,2,3 ----
    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<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('N4=',N4,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))
        p1=tuple(p1); p2=tuple(p2); p3=tuple(p3);
        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
    imgTLx=np.copy(imgTL); 
    #cv2.imshow('imgTLx',imgTLx)
    XA1=0; XA2=imgTL.shape[1]; YA1=0; YA2=imgTL.shape[0]; 
    XA1,XA2,imx=borderVL(0.6,imgTL)
    imgT2=imgTL[YA1:YA2,XA1:XA2,:]
    YA1,YA2,imy=borderHL(imgT2)
    imgT2=imgTL[YA1:YA2,XA1:XA2,:]; imgTL=np.copy(imgT2)
    LTx=imgTL.shape[1]; LTy=imgTL.shape[0];
    newT=np.full((LTy,LTx+5,3),255,dtype=np.uint8)
    newT[:,0:LTx,:]=imgTL[:,:,:]
    #cv2.imshow('newT',newT)
    imgTL=np.copy(newT)
    #cv2.imshow('TL',imgTL)
    #cv2.waitKey(0)
    hsv=cv2.cvtColor(imgTL,cv2.COLOR_BGR2HSV)
    avL,avH=HLA(hsv); WHITE=int(avH*0.5)
    lowT=np.array([0,0 ,WHITE]); uppT=np.array([255,120 ,255])
    maskT=cv2.inRange(hsv,lowT,uppT)
    mask3=maskT
    bina=np.copy(mask3); Lbx=bina.shape[1]; Lby=bina.shape[0]; w8=Lbx/8
    #.....................................................AN3 2nd contour for Numbers
    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=[]; HN=[]; WN=[]
    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),Lby*0.3,Lbx*0.4,c,40)
        if(ar<200 or d<Lby*0.3): continue
        if(c>Lbx*0.4): continue
        #if(c<40): continue
        if(c/d>0.6): continue
        if(c<w8*0.4 and d<Lby*0.2): continue
        if(d>LTy*0.8 and c<8): continue
        N4+=1
        #print('TL_N4=',N4,(a,b,c,d,ar))
        cv2.rectangle(gr5,(a,b-2),(a+c,b+d+2),50,1)
        E=2
        numc=gr4[b-E:b+d+E,a-E:a+c+E]; nx=numc.shape[1]; ny=numc.shape[0]
        if(nx<2 or ny<2 or nx>Lbx-3 or ny>Lby-3): numc=gr4[b:b+d,a:a+c]
        #print('numc.shape=',numc.shape,a-E,a+c+E)
        NUM.append(numc)
        data4.append([a,b,c,d]); XN.append(a); WN.append(c); HN.append(d)

    #print('XN_1=',XN)
    #print('N4=',N4,' lenNUM=',len(NUM))
    #for a in range(N4):
        #print('a=',a,data4[a])
        #cv2.imshow('NUM',NUM[a])
        #cv2.waitKey(0)

    #print('XN_A0=',XN)
    avW=round(np.average(WN),1); avH=round(np.average(HN),1)
    XN2=XN.copy(); HN2=HN.copy(); WN2=WN.copy(); NUM2=NUM.copy()
    XN=[]; HN=[]; WN=[]; data=[]; NUM=[]; NN=0
    for i in range(len(XN2)):
        #print(i,data4[i])
        if(WN2[i]<avW*0.8 and HN2[i]<avH*0.8): 
            #print('ER,WN=',WN2[i],HN2[i]);
            continue
        NN+=1; NUM.append(NUM2[i])
        XN.append(XN2[i]);data.append(data4[i]);WN.append(WN2[i]);HN.append(HN2[i])
        #print('NN=',NN,'XN=',XN)

    #XN=XN2.copy(); WN=WN2.copy(); HN=HN2.copy()
    len1=len(XN)
    XN0=XN.copy()
    #print('len1=',len1,'XN_A=',XN,WN,HN)
    #print('LWN=',len(WN),' WN=',WN)
    if(len1<2): 
        #input('WWWW')
        return imgTL,[],[]
    Wav=int(np.average(WN)); Wavc=int(Wav*2.2); XR=sorted(XN0);
    #print('XN_B=',XN)
    XN2=XN.copy();WN2=WN.copy();HN2=HN.copy();data2=data4.copy()
    #print('XN_12=',XN2)
    nt=0; #print('Wav=',Wav,Wavc)
    for t in range(len1-1):
        if(XR[t+1]-XR[t]>Wavc):
            nt+=1
            Xt=int((XR[t+1]+XR[t])/2)
            Wt=XR[t+1]-Xt
            Ht=HN[t]
            dt=[Xt,data4[t][1],Wt,Ht]
            numc=gr4[dt[1]:dt[1]+dt[3],dt[0]:dt[0]+dt[2]];
            #cv2.imshow('numc',numc)
            #cv2.waitKey(0)
            XN2.append(Xt);WN2.append(Wt);HN2.append(Ht);data2.append(dt);NUM.append(numc)
            #print('nt=',nt,XR[t],XR[t+1],dt)

    XN=XN2.copy(); WN=WN2.copy(); HN=HN2.copy(); data4=data2.copy()
    #print('XN_2=',XN)
    XS=sorted(XN); NUM2=[]; WS=[]; #print('XN=',XN,' XS=',XS)
    #print('bina.shape=',bina.shape,' NN=',NN,' lenXS=',len(XS),XS)
    for i in range(len(XS)):
        k=XN.index(XS[i])
        if(i<len(XS)-1): dX=XS[i+1]-XS[i]
        else: dX=0
        #print(i,k,XS[i],dX,WN[k],HN[k])
    for i in range(len(XS)):
        k=XN.index(XS[i])
        #print(i,k,(XS[i],XN[k]),data4[k])
        NUM2.append(NUM[k])
        WS.append(WN[k])
        #cv2.imshow('N_'+str(k),NUM[k])
        #cv2.waitKey(0)
        #print(i,'k=',k,NUM[k].shape)
    #input('KKKK')
    Lnum2=len(NUM2)
    print('Lnum2=',Lnum2,XS,' WS=',WS)
    #cv2.imshow('TL_gr5',gr5); 
    if(len(NUM2)<7): 
        #cv2.imshow('TL_gr5',gr5); 
        print('error lenNUM2=',len(NUM2))
    #if(Lnum2<7): cv2.waitKey(0)
    #cv2.waitKey(0)
    cv2.destroyAllWindows();
    return imgTL,data4,NUM2
        




#----------------------BLKBLK-------
def WboxBLK(image):
    #---------------------------- white color----------
    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)
    gray=cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
    avL,avH=HLA(hsvrs)
    H10,L10=highlow(hsv,YC); HC=H10; BLK=HC-50; BLK=50; 
    rtw=0.8; WHITE=int(avH*rtw); #if too black, reduce rtw
    if(WHITE<165): print('low white,original_white=',WHITE); #WHITE=165
    #----------------------------- mask on black
    low1=np.array([0,80 ,0])
    upp1=np.array([255,255 ,210])
    lowT=np.array([0,0 ,WHITE])
    uppT=np.array([255,120 ,255])
    #-----------------------------
    maskT=cv2.inRange(hsv,lowT,uppT)
    mask3=maskT
    imC=cv2.bitwise_and(img,img,mask=mask3)
    imCs=cv2.resize(imC,(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=[]; IMGSA=[]; PLAT=[]; PNUM=[]; dataAN=[]; TL=[]
    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,:]
        sgr=gray[y:y+h,x:x+w]
        #----------------------- crop plate for large-size rect
        KF=0
        if(w>400 and h>50): 
            #cv2.imshow('sgr',sgr); 
            imgsub,XA,XB,YA,YB=SUBGR(imgc)
            (x,y,w,h)=(x+XA,y+YA,XB-XA,YB-YA)
            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,:]
            KF=1
            if(h<10 or w<40): KF=2
            if(h>120 or w>400): KF=3
            if(asp<0.2 or asp>0.8): KF=4
            if(KF>1): continue
            print('KF=',KF,' SUB_xx1=',xx1,asp,Ac,ratA,'shape:',sgr.shape,imgc.shape)
            cv2.imshow('imgc_sub',imgc)
            #cv2.waitKey(0)
        if(h<30 or w<90): continue
        if(Ac<1000): continue
        if(w>700): continue
        DBW,avH,avL,Dav=DBKWT(imgc)
        #if(KF==1): print('DBK_imgc=',imgc.shape,xx1,' DBW=',DBW,avH,avL,Dav)
        if(DBW==0): continue
        if(asp<0.1): continue
        elif(0.1<=asp<0.6): 
            #if(KF==1): print('I am here 1 asp=',asp)
            KHL=1; NHL=100
            KC,NSW=censcan(imgc); RSW=round(NSW/w,2)
            #if(KF==1): print('KF=1, KC=',KC,NSW,RSW)
            if(KC==0 or NSW<3 or RSW<0.01): 
                #if(KF==1): print('KF=',KF,' KC=',KC,NSW,RSW)
                continue
            KHL,NHL=CKHL(imgc)
            #if(KF==1): print('KF=1, KHL=',KHL,NHL); cv2.waitKey(0); input('2222')
            if(KHL==0): 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(KF==1): print('I am here 2')
        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); 
        EW=35; EW2=EW*2
        if(y>EW and y+h<Ly-EW and x>EW2 and x+w<Lx-EW2):
            grc=gr1[y-EW:y+h+EW,x-EW2:x+w+EW2]
            grd=img[y-EW:y+h+EW,x-EW2:x+w+EW2]
        else:
            EW=20; EW2=EW*2
            if(y>EW and y+h<Ly-EW and x>EW2 and x+w<Lx-EW2):
                grc=gr1[y-EW:y+h+EW,x-EW2:x+w+EW2]
                grd=img[y-EW:y+h+EW,x-EW2:x+w+EW2]
            else:
                EW=2; EW2=EW*2
                grc=gr1[y-EW:y+h+EW,x-EW2:x+w+EW2]
                grd=img[y-EW:y+h+EW,x-EW2:x+w+EW2]
        #if(KF==1): print('I am here 3')
        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
        if(asp<0.2 or asp>0.8): continue
        #-------------------------------------------
        Nac+=1
        #print('Wb,Nac=',Nac,Nc,xx1,asp,(DBW,avH,avL,Dav),(KC,NSW),(KHL,NHL))
        cv2.rectangle(imgb,(x,y),(x+w,y+h),(255,75,0),20)
        data1.append(xx1)
        PLAT.append(grd)
        imgbs=cv2.resize(imgb,(X2,Y2))
        #cv2.imshow('imgb',imgbs)
        #cv2.imshow('grd',grd)
        #cv2.waitKey(0)
        img4t=np.copy(grd)
        if(KAN==0): continue

        #==================================================== AN3 ======
        imgTL,data4,NUM=AN3(img4t); 
        cv2.destroyAllWindows();
        #===============================================================
        TL.append(imgTL)
        PNUM.append(NUM)
        dataAN.append(data4)
        nt=0
        #for t in NUM: nt+=1; cv2.imshow('NUM_'+str(nt),t)
        #cv2.waitKey(0)

    if(KAN==0): imgTL=np.copy(img4t); PNUM=[]; data4=[]; dataAN=[]
    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,' data1=',data1,' lenPLAT=',len(PLAT),' lenPNUM=',len(PNUM))
    #cv2.waitKey(0)
    return Nac,data1,PLAT,TL,PNUM,dataAN







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
    KAN=1
    tm1=time.time(); 
    FW=open('plate.txt','w'); FW2=open('pnum.txt','w')
    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)

        #============================================     M-WboxBLK
        #lenda2,data2,gr3=WboxBLK(imgi)
        Nac,data1,PLAT,TL,PNUM,dataAN=WboxBLK(imgi)
        #============================================
        print('back in Main from Wbox...len(PLAT)=',len(PLAT),len(TL),len(PNUM))
        cv2.destroyAllWindows();
        fn0=fn+'.png'
        cv2.imwrite(fn0,PLAT[0])
        if(KAN==1):
            s=data1; s.insert(0,j)
            FW.write(str(s)+'\n')
            s2=[(j,Nac)]
            for t in range(Nac): s2.append(len(PNUM[t]))
            FW2.write(str(s2)+'\n')
            #print('s=',s,' s2=',s2)
        for t in range(1,Nac+1):
            fnt=fn+'_'+str(t).zfill(2)+'.png'
            #cv2.imwrite(fnt,PLAT[t]);
            #if(KAN==0): cv2.imshow('PL',PLAT[t]); cv2.waitKey(0)
            #if(KAN==1): cv2.imshow('TL',TL[t-1]); cv2.waitKey(0)
            if(KAN==0): continue

            fntL=fn+'_L'+str(t).zfill(2)+'.png'
            cv2.imwrite(fntL,TL[t-1])
            hVL=100
            VL=np.full((hVL,5),128,dtype=np.uint8)
            PB=np.full((100,100),255,dtype=np.uint8)
            hsta=np.copy(VL)
            #cv2.imshow('hsta',hsta)
            for s in range(len(PNUM[t-1])):
                pts=PNUM[t-1][s]
                r=hVL/pts.shape[0]
                RX=int(pts.shape[1]*r); 
                if(RX>100): RX=100
                #print(t,s,'pts.shape=',pts.shape,RX,hVL)
                pts2=cv2.resize(pts,(RX,hVL)); XN=pts2.shape[1]
                IX=50-int(XN/2)
                #print('pts.shape=',pts.shape,pts2.shape,PB.shape,XN,IX)
                pts3=np.copy(PB); pts3[:,IX:IX+XN]=pts2[:,:]
                hsta=np.hstack((hsta,pts3)); hsta=np.hstack((hsta,VL))
                #print(t,len(PNUM[t-1]),pts.shape,pts2.shape,hsta.shape)
                fnts=fn+'_N'+str(t).zfill(2)+'_'+str(s)+'.png'
                #cv2.imwrite(fnts,PNUM[t-1][s])
                cv2.imwrite(fnts,pts3)
                #cv2.imshow('TLN'+str(s),PNUM[t-1][s])
            cv2.imshow('hsta',hsta)
            #cv2.imshow('plat_'+str(t).zfill(2),PLAT[t])
            cv2.waitKey(0)
        print('j_file=',j,fn,Nac,data1[0:2],'\n\n')
        #input('11111')
        #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)


tm2=time.time()
ttm0=round(tm1-tm0,3)
ttm=round(tm2-tm1,3)
print('ttm0=',ttm0,' ttm=',ttm)
FW.close()
FW2.close()
#cv2.waitKey(0)
cv2.destroyAllWindows();
#cap.release()