782 lines
30 KiB
Python
782 lines
30 KiB
Python
import random
|
|
import gc
|
|
from tracemalloc import Statistic
|
|
import cv2
|
|
import numpy as np
|
|
import os
|
|
import copy
|
|
import csv
|
|
import textwrap
|
|
from PIL import Image, ImageFont, ImageDraw, ImageColor, PngImagePlugin
|
|
from modules import images, sd_models, devices
|
|
from modules.sd_models import load_model
|
|
from modules.shared import opts
|
|
from scripts.mergers.mergers import TYPES,FINETUNEX,smerge,simggen,filenamecutter,draw_origin,wpreseter,savestatics,cachedealer,get_font
|
|
from scripts.mergers.model_util import savemodel
|
|
from scripts.mergers.bcolors import bcolors
|
|
|
|
hear = True
|
|
hearm = False
|
|
|
|
state_mergen = False
|
|
|
|
RANDCOL = 10
|
|
NUM = "num"
|
|
RAND = "random"
|
|
|
|
numadepth = []
|
|
|
|
def freezetime():
|
|
global state_mergen
|
|
state_mergen = True
|
|
|
|
def numanager(startmode,xtype,xmen,ytype,ymen,ztype,zmen,esettings,
|
|
weights_a,weights_b,model_a,model_b,model_c,alpha,beta,mode,calcmode,
|
|
useblocks,custom_name,save_sets,id_sets,wpresets,deep,fine,bake_in_vae,
|
|
s_prompt,s_nprompt,s_steps,s_sampler,s_cfg,s_seed,s_w,s_h,s_batch_size,
|
|
genoptions,s_hrupscaler,s_hr2ndsteps,s_denois_str,s_hr_scale,
|
|
lmode,lsets,llimits_u,llimits_l,lseed,lserial,lcustom,lround,
|
|
*txt2imgparams):
|
|
|
|
cachedealer(True)
|
|
|
|
global numadepth
|
|
grids = []
|
|
sep = "|"
|
|
|
|
if RAND in startmode:
|
|
if "off" in lmode:
|
|
cachedealer(False)
|
|
return "Random mode is off",*[None]*5
|
|
if lserial > 0 : lseed = -1
|
|
useblocks = True
|
|
if RAND in startmode or TYPES.index(RAND) in [xtype,ytype,ztype]:
|
|
xtype,xmen,ytype,ymen,weights_a,weights_b = crazyslot(lmode,lsets,llimits_u,llimits_l,lseed,lserial,lcustom,xtype,xmen,ytype,ymen,weights_a,weights_b,startmode)
|
|
|
|
lucks = {"on":startmode == RAND, "mode":lmode,"set":lsets,"upp":llimits_u,"low":llimits_l,"seed":lseed,"num":lserial,"cust":lcustom,"round":int(lround)}
|
|
gensets_s = [s_prompt,s_nprompt,s_steps,s_sampler,s_cfg,s_seed,s_w,s_h,s_batch_size,genoptions,s_hrupscaler,s_hr2ndsteps,s_denois_str,s_hr_scale]
|
|
|
|
allsets = [xtype,xmen,ytype,ymen,ztype,zmen,esettings,
|
|
weights_a,weights_b,model_a,model_b,model_c,alpha,beta,mode,calcmode,
|
|
useblocks,custom_name,save_sets,id_sets,wpresets,deep,fine,bake_in_vae,
|
|
txt2imgparams,gensets_s,lucks]
|
|
|
|
from scripts.mergers.components import paramsnames
|
|
seed = txt2imgparams[paramsnames.index("Seed")]
|
|
|
|
if RAND not in startmode:
|
|
if sep in xmen: allsets = separator(allsets,1,sep,xmen,seed,startmode)
|
|
if sep in ymen: allsets = separator(allsets,3,sep,ymen,seed,startmode)
|
|
if sep in zmen: allsets = separator(allsets,5,sep,zmen,seed,startmode)
|
|
|
|
if "reserve" in startmode :
|
|
cachedealer(False)
|
|
return numaker(allsets)
|
|
|
|
if "normal" or RAND in startmode:
|
|
result,currentmodel,xyimage,a,b,c= sgenxyplot(*allsets)
|
|
if xyimage is not None:grids = xyimage
|
|
else:print(result)
|
|
else:
|
|
if numadepth ==[]:
|
|
cachedealer(False)
|
|
return "no reservation",*[None]*5
|
|
result=currentmodel=xyimage=a=b=c = None
|
|
|
|
while True:
|
|
for i,row in enumerate(numadepth):
|
|
if row[1] =="waiting":
|
|
numadepth[i][1] = "Operating"
|
|
try:
|
|
result,currentmodel,xyimage,a,b,c = sgenxyplot(*row[2:])
|
|
except Exception as e:
|
|
print(e)
|
|
numadepth[i][1] = "Error"
|
|
else:
|
|
if xyimage is not None:
|
|
grids.append(xyimage[0])
|
|
numadepth[i][1] = "Finished"
|
|
else:
|
|
print(result)
|
|
numadepth[i][1] = "Error"
|
|
wcounter = 0
|
|
for row in numadepth:
|
|
if row[1] != "waiting":
|
|
wcounter += 1
|
|
if wcounter == len(numadepth):
|
|
break
|
|
|
|
gc.collect()
|
|
cachedealer(False)
|
|
|
|
return result,currentmodel,grids,a,b,c
|
|
|
|
def separator(allsets,index,sep,men,seed,startmode):
|
|
if seed =="-1": allsets[30] = str(random.randrange(4294967294))
|
|
mens = men.split(sep)
|
|
if "reserve" not in startmode:
|
|
allsets[index] = mens[0]
|
|
for men in mens[1:]:
|
|
numaker([*allsets[0:index],men,*allsets[index+1:]])
|
|
else:
|
|
allsets[index] = mens[-1]
|
|
for men in mens[:-1]:
|
|
numaker([*allsets[0:index],men,*allsets[index+1:]])
|
|
return allsets
|
|
|
|
def numaker(allsets):
|
|
global numadepth
|
|
numadepth.append([len(numadepth)+1,"waiting",*allsets])
|
|
return numalistmaker(copy.deepcopy(numadepth))
|
|
|
|
def nulister(redel):
|
|
global numadepth
|
|
if redel == False:
|
|
return numalistmaker(copy.deepcopy(numadepth))
|
|
if redel ==-1:
|
|
numadepth = []
|
|
else:
|
|
try:del numadepth[int(redel-1)]
|
|
except Exception as e:print(e)
|
|
return numalistmaker(copy.deepcopy(numadepth))
|
|
|
|
def numalistmaker(numa):
|
|
if numa ==[]: return [["no data","",""],]
|
|
for i,r in enumerate(numa):
|
|
r[2] = TYPES[int(r[2])]
|
|
r[4] = TYPES[int(r[4])]
|
|
r[6] = TYPES[int(r[6])]
|
|
numa[i] = r[0:8]+r[11:14]+r[14:18]+r[9:11]
|
|
return numa
|
|
|
|
def caster(news,hear):
|
|
if hear: print(news)
|
|
|
|
def sgenxyplot(xtype,xmen,ytype,ymen,ztype,zmen,esettings,
|
|
weights_a,weights_b,model_a,model_b,model_c,alpha,beta,mode,
|
|
calcmode,useblocks,custom_name,save_sets,id_sets,wpresets,deep,fine,bake_in_vae,
|
|
gensets,gensets_s,lucks):
|
|
global hear
|
|
esettings = " ".join(esettings)
|
|
savestat = "savestat" in deep
|
|
|
|
gensets = list(gensets)
|
|
|
|
from scripts.mergers.components import paramsnames
|
|
def g(wanted,wantedv=None,value = True):
|
|
if wanted in paramsnames:return gensets[paramsnames.index(wanted)] if value else paramsnames.index(wanted)
|
|
elif wantedv and wantedv in paramsnames:return gensets[paramsnames.index(wantedv)] if value else paramsnames.index(wantedv)
|
|
else:return None if value else 0
|
|
|
|
fine = fine.split(",") if fine else [0]*7
|
|
|
|
|
|
|
|
deep_ori = deep
|
|
#type[0:none,1:aplha,2:beta,3:seed,4:mbw,5:model_A,6:model_B,7:model_C,8:pinpoint 9:deep]
|
|
xtype = TYPES[xtype]
|
|
ytype = TYPES[ytype]
|
|
ztype = TYPES[ztype]
|
|
XYZ =xtype + ytype + ztype
|
|
mainmodel = mainmodeldealer(XYZ)
|
|
#ALL
|
|
if "ALL" in [xmen,ymen,zmen]:
|
|
xmen,ymen,zmen = alldealer([xmen,ymen,zmen],[xtype,ytype,ztype])
|
|
|
|
if ytype == "none": ymen = ""
|
|
if ztype == "none": zmen = ""
|
|
|
|
modes=["Weight" ,"Add" ,"Triple","Twice"]
|
|
xs=ys=ys=0
|
|
weights_a_in=weights_b_in="0"
|
|
|
|
deepprint = True if "print change" in esettings else False
|
|
|
|
def castall(hear):
|
|
if hear :print(f"xmen:{xmen}, ymen:{ymen},zmen:{zmen}, xtype:{xtype}, ytype:{ytype}, ztype:{ztype}\
|
|
weights_a:{weights_a_in}, weights_b:{weights_b_in}, model_A:{model_a},model_B :{model_b}, model_C:{model_c}, alpha:{alpha},\
|
|
beta :{beta}, mode:{mode}, blocks:{useblocks}")
|
|
|
|
pinpoint = "pinpoint blocks" in XYZ and "alpha" in XYZ
|
|
|
|
usebeta = modes[2] in mode or modes[3] in mode
|
|
|
|
if "prompt" in XYZ: gensets_s[0] = ""
|
|
if "seed" in XYZ: gensets_s[5] = 0
|
|
|
|
#check and adjust format
|
|
print(f"\n{bcolors.OKGREEN}XY plot start, mode:{mode}, X: {xtype}, Y: {ytype}, Z: {ztype} MBW: {useblocks}{bcolors.ENDC}")
|
|
castall(hear)
|
|
None5 = [None,None,None,None,None]
|
|
if xmen =="": return "ERROR: parameter X is empty",*None5
|
|
if ymen =="" and not ytype=="none": return "ERROR: parameter Y is empty",*None5
|
|
if zmen =="" and not ztype=="none": return "ERROR: parameter Z is empty",*None5
|
|
if model_a ==[] and "model_A" not in XYZ:return f"ERROR: model_A is not selected",*None5
|
|
if model_b ==[] and "model_B" not in XYZ:return f"ERROR: model_B is not selected",*None5
|
|
if model_c ==[] and usebeta and "model_C" not in XYZ:return "ERROR: model_C is not selected",*None5
|
|
if xtype == ytype and not (xtype == "add elemental" or xtype == RAND): return "ERROR: same type selected for X,Y",*None5
|
|
|
|
if useblocks:
|
|
weights_a_in=wpreseter(weights_a,wpresets)
|
|
weights_b_in=wpreseter(weights_b,wpresets)
|
|
|
|
#for X only plot, use same seed
|
|
if g("Seed") == -1: gensets[g("Seed",value=False)] = int(random.randrange(4294967294))
|
|
|
|
#gensets :prompt:1,seed:11
|
|
#gensets_s :prompt:0, seed:5
|
|
|
|
#for XY plot, use same seed
|
|
def dicedealer(zs):
|
|
for i,z in enumerate(zs):
|
|
if z =="-1": zs[i] = str(random.randrange(4294967294))
|
|
print(f"the die was thrown : {zs}")
|
|
|
|
#adjust parameters, alpha,beta,models,seed: list of single parameters, mbw(no beta):list of text,mbw(usebeta); list of pair text
|
|
def adjuster(wmen,wtype,awtype,bwtype):
|
|
if "mbw" in wtype or "prompt" in wtype or "adjust" == wtype:#men separated by newline
|
|
ws = wmen.splitlines()
|
|
caster(ws,hear)
|
|
if "mbw alpha and beta" in wtype:
|
|
ws = [ws[i:i+2] for i in range(0,len(ws),2)]
|
|
caster(ws,hear)
|
|
elif "elemental" in wtype:
|
|
ws = wmen.split("\n\n")
|
|
elif RAND in wtype:
|
|
ws = [""] * int(wmen)
|
|
else:
|
|
if "pinpoint element" in wtype:
|
|
wmen = wmen.replace("\n",",")
|
|
if "effective" in wtype:
|
|
wmen = ","+wmen
|
|
wmen = wmen.replace("\n",",")
|
|
ws = [w.strip() for w in wmen.split(',')]
|
|
caster(ws,hear)
|
|
if "alpha" in wtype and ("effective" in awtype or "effective" in bwtype):
|
|
ws = [ws[0]]
|
|
if "seed" in wtype:dicedealer(ws)
|
|
if "alpha" == wtype or "beta" == wtype:
|
|
ow = []
|
|
for w in ws:
|
|
try:
|
|
float(w)
|
|
ow.append(w)
|
|
except:
|
|
pass
|
|
ws = ow
|
|
return ws
|
|
|
|
xs = adjuster(xmen,xtype,ytype,ztype)
|
|
ys = adjuster(ymen,ytype,xtype,ztype)
|
|
zs = adjuster(zmen,ztype,xtype,ytype)
|
|
|
|
#in case beta selected but mode is Weight sum or Add or Diff
|
|
if ("beta" in XYZ) and (not usebeta and "tensor" not in calcmode):
|
|
mode = modes[3]
|
|
print(f"{bcolors.WARNING}{modes[3]} mode automatically selected){bcolors.ENDC}")
|
|
|
|
#in case mbw or pinpoint selected but useblocks not chekced
|
|
if "mbw" in XYZ and not useblocks:
|
|
useblocks = True
|
|
print(f"{bcolors.WARNING}MBW mode enabled{bcolors.ENDC}")
|
|
|
|
xcount = ycount = zcount = 0
|
|
allcount = len(xs)*len(ys)*len(zs) if not lucks["on"] else lucks["num"]
|
|
|
|
#for STOP XY bottun
|
|
flag = False
|
|
global state_mergen
|
|
state_mergen = False
|
|
|
|
#type[0:none,1:aplha,2:beta,3:seed,4:mbw,5:model_A,6:model_B,7:model_C,8:pinpoint ]
|
|
blockid=["BASE","IN00","IN01","IN02","IN03","IN04","IN05","IN06","IN07","IN08","IN09","IN10","IN11","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08","OUT09","OUT10","OUT11"]
|
|
#format ,IN00 IN03,IN04-IN09,OUT4,OUT05
|
|
def weightsdealer(xyzval: list,xyztype: list,weights: str, mode: str):
|
|
caster(f"weights from : {weights}",hear)
|
|
ww = xyzval[xyztype.index("pinpoint blocks")]
|
|
wa = xyzval[xyztype.index(mode)]
|
|
ww = [w.strip() for w in ww.split(' ')]
|
|
weights_t = [w.strip() for w in weights.split(',')]
|
|
if ww[0]!="NOT":
|
|
flagger=[False]*26
|
|
changer = True
|
|
else:
|
|
flagger=[True]*26
|
|
changer = False
|
|
for w in ww:
|
|
if w =="NOT":continue
|
|
if "-" in w:
|
|
wt = [wt.strip() for wt in w.split('-')]
|
|
if blockid.index(wt[1]) > blockid.index(wt[0]):
|
|
flagger[blockid.index(wt[0]):blockid.index(wt[1])+1] = [changer]*(blockid.index(wt[1])-blockid.index(wt[0])+1)
|
|
else:
|
|
flagger[blockid.index(wt[1]):blockid.index(wt[0])+1] = [changer]*(blockid.index(wt[0])-blockid.index(wt[1])+1)
|
|
else:
|
|
flagger[blockid.index(w)] =changer
|
|
for i,f in enumerate(flagger):
|
|
if f:weights_t[i]=wa
|
|
outext = ",".join(weights_t)
|
|
caster(f"weights changed: {outext}",hear)
|
|
return outext
|
|
|
|
def abdealer(z):
|
|
if " " in z:return z.split(" ")[0],z.split(" ")[1]
|
|
return z,z
|
|
|
|
def xydealer(w,wt,awt,bwt):
|
|
wta = awt + bwt
|
|
nonlocal alpha,beta,gensets,weights_a_in,weights_b_in,model_a,model_b,model_c,deep,calcmode,fine
|
|
if "prompt" in wt:
|
|
gensets[1] = w
|
|
return
|
|
if "pinpoint blocks" in wt or "pinpoint element" in wt or "effective" in wt:return
|
|
if "mbw" in wt:
|
|
def weightser(w):return w, w.split(',',1)[0]
|
|
if "mbw alpha and beta" in wt:
|
|
weights_a_in,alpha = weightser(wpreseter(w[0],wpresets))
|
|
weights_b_in,beta = weightser(wpreseter(w[1],wpresets))
|
|
elif "alpha" in wt:
|
|
weights_a_in,alpha = weightser(wpreseter(w,wpresets))
|
|
else:
|
|
weights_b_in,beta = weightser(wpreseter(w,wpresets))
|
|
return
|
|
if "alpha and" in wt:
|
|
alpha,beta = abdealer(w)
|
|
return
|
|
if "alpha" in wt and not ("pinpoint element" in wta or "effective" in wta or "pinpoint adjust" in wta):alpha = w
|
|
if "beta" in wt: beta = w
|
|
if "seed" in wt:
|
|
gensets[g("Seed",value = False)] = int(w)
|
|
if "model_A" in wt:model_a = w
|
|
if "model_B" in wt:model_b = w
|
|
if "model_C" in wt:model_c = w
|
|
if "elemental" in wt:
|
|
deep = deep +","+ w if "add" in wt else w
|
|
if "calcmode" in wt:calcmode = w
|
|
if "adjust" == wt:fine = w
|
|
|
|
def elementdealer(xyzval,xyztype):
|
|
t = "pinpoint element" if "pinpoint element" in xyztype else "effective"
|
|
return str(xyzval[xyztype.index(t)]) + ":" + str(xyzval[xyztype.index("alpha")])
|
|
|
|
def finedealer(fine,xyzval: list,xyztype: list):
|
|
f = xyzval[xyztype.index("pinpoint adjust")]
|
|
a = xyzval[xyztype.index("alpha")]
|
|
fine_in = fine.copy()
|
|
fine_in[FINETUNEX.index(f)] = a
|
|
return fine_in
|
|
|
|
# plot start
|
|
|
|
xyzimage=[]
|
|
for z in zs:
|
|
ycount = 0
|
|
xyimage = []
|
|
xydealer(z,ztype,xtype,ytype)
|
|
for y in ys:
|
|
deep = deep_ori
|
|
xydealer(y,ytype,xtype,ztype)
|
|
xcount = 0
|
|
for x in xs:
|
|
deepy = deep
|
|
xyzv= [x,y,z]
|
|
xyzt = [xtype,ytype,ztype]
|
|
xydealer(x,xtype,ytype,ztype)
|
|
if pinpoint and "alpha" in XYZ:
|
|
weights_a_in = weightsdealer(xyzv,xyzt,weights_a,"alpha")
|
|
weights_b_in = weights_b
|
|
if pinpoint and "beta" in XYZ:
|
|
weights_b_in = weightsdealer(xyzv,xyzt,weights_b,"beta")
|
|
weights_a_in = weights_a
|
|
if "pinpoint element" in XYZ or "effective" in XYZ:
|
|
deep_in = deep + "," + elementdealer(xyzv,xyzt) if deep else elementdealer(xyzv,xyzt)
|
|
else:
|
|
deep_in = deep
|
|
if "pinpoint adjust" in XYZ and "alpha" in XYZ:
|
|
fine_in = finedealer(fine,xyzv,xyzt)
|
|
else:
|
|
fine_in = fine
|
|
if type(fine_in) == list:fine_in = ",".join([str(x) for x in fine_in])
|
|
|
|
print(f"{bcolors.OKGREEN}XY plot: X: {xtype}, {str(x)}, Y: {ytype}, {str(y)}, Z: {ztype}, {str(z)} ({len(xs)*len(ys)*zcount + ycount*len(xs) +xcount +1}/{allcount}){bcolors.ENDC}")
|
|
if not (((xtype=="seed") or (xtype=="prompt")) and xcount > 0):
|
|
_, currentmodel,modelid,theta_0, metadata =smerge(weights_a_in,weights_b_in, model_a,model_b,model_c, float(alpha),float(beta),mode,calcmode,
|
|
useblocks,"","",id_sets,False,deep_in,fine_in,bake_in_vae,deepprint = deepprint,lucks = lucks,main=mainmodel)
|
|
checkpoint_info = sd_models.get_closet_checkpoint_match(model_a)
|
|
sd_models.model_data.__init__()
|
|
load_model(checkpoint_info, already_loaded_state_dict=theta_0)
|
|
|
|
if "save model" in esettings:
|
|
savemodel(theta_0,currentmodel,custom_name,save_sets,metadata)
|
|
theta_0 = None
|
|
del theta_0
|
|
|
|
if xcount == 0: statid = modelid
|
|
|
|
image_temp = simggen(*gensets_s,currentmodel,id_sets,modelid,*gensets)
|
|
gc.collect()
|
|
devices.torch_gc()
|
|
|
|
xyimage.append(image_temp[0][0])
|
|
xcount+=1
|
|
deep = deepy
|
|
if state_mergen:
|
|
flag = True
|
|
break
|
|
if lucks["on"] and (len(xs)*len(ys)*zcount + ycount*len(xs) +xcount +1) >= lucks["num"]: flag = True
|
|
ycount+=1
|
|
if flag:break
|
|
|
|
if flag and ycount ==1:
|
|
xs = xs[:xcount]
|
|
ys = [ys[0],]
|
|
print(f"stopped at x={xcount},y={ycount}")
|
|
elif flag:
|
|
ys = ys[:ycount]
|
|
print(f"stopped at x={xcount},y={ycount}")
|
|
|
|
(xs_t, ys_t) = (xs.copy(), ys.copy())
|
|
|
|
if "mbw alpha and beta" in xtype: xs_t = [f"alpha:({x[0]}),beta({x[1]})" for x in xs ]
|
|
if "mbw alpha and beta" in ytype: ys_t = [f"alpha:({y[0]}),beta({y[1]})" for y in ys ]
|
|
|
|
xs_t[0]=xtype+" = "+xs_t[0] #draw X label
|
|
if ytype!=TYPES[0] or "model" in ytype:ys_t[0]=ytype+" = "+ys[0] #draw Y label
|
|
|
|
if ys_t==[""]:ys_t = [" "]
|
|
|
|
if "effective" in xtype or "effective" in ytype:
|
|
xyimage,xs_t,ys_t = effectivechecker(xyimage,xs_t,ys_t,model_a,model_b,esettings)
|
|
|
|
if not "grid" in esettings:
|
|
if "swap XY" in esettings:
|
|
xyimage, xs_t, ys_t = swapxy(xyimage, xs_t, ys_t)
|
|
gridmodel= makegridmodelname(model_a, model_b,model_c, useblocks,mode,xtype,ytype,alpha,beta,weights_a,weights_b,usebeta)
|
|
grid = smakegrid(xyimage,xs_t,ys_t,gridmodel,image_temp[4])
|
|
xyimage.insert(0,grid)
|
|
|
|
if savestat: savestatics(statid)
|
|
|
|
zcount+=1
|
|
xyzimage.append(xyimage[0])
|
|
if flag: break
|
|
|
|
state_mergen = False
|
|
return "Finished",currentmodel,xyzimage,*image_temp[1:4]
|
|
|
|
def smakegrid(imgs,xs,ys,currentmodel,p):
|
|
xs = [makemultilineweight(x) for x in xs]
|
|
ys = [makemultilineweight(y) for y in ys]
|
|
|
|
ver_texts = [[images.GridAnnotation(y)] for y in ys]
|
|
hor_texts = [[images.GridAnnotation(x)] for x in xs]
|
|
|
|
w, h = imgs[0].size
|
|
grid = Image.new('RGB', size=(len(xs) * w, len(ys) * h), color='black')
|
|
|
|
for i, img in enumerate(imgs):
|
|
grid.paste(img, box=(i % len(xs) * w, i // len(xs) * h))
|
|
|
|
grid = draw_grid_annotations(grid,w,h, hor_texts, ver_texts)
|
|
grid = draw_origin(grid, currentmodel,w*len(xs),h*len(ys),w)
|
|
if opts.grid_save:
|
|
images.save_image(grid, opts.outdir_txt2img_grids, "xy_grid", extension=opts.grid_format, prompt=p.prompt, seed=p.seed, grid=True, p=p)
|
|
|
|
return grid
|
|
|
|
def makemultilineweight(weight):
|
|
i = 0
|
|
o = ""
|
|
for c in weight:
|
|
o += c
|
|
i += 1
|
|
if i > 25:
|
|
if c == ",":
|
|
o += "\n"
|
|
i = 0
|
|
return o
|
|
|
|
def swapxy(imgs,xs,ys):
|
|
nimgs = []
|
|
for x in range(len(xs)):
|
|
for y in range(len(ys)):
|
|
nimgs.append(imgs[y * len(xs) + x])
|
|
return nimgs, ys, xs
|
|
|
|
def makegridmodelname(model_a, model_b,model_c, useblocks,mode,xtype,ytype,alpha,beta,wa,wb,usebeta):
|
|
model_a=filenamecutter(model_a)
|
|
model_b=filenamecutter(model_b)
|
|
model_c=filenamecutter(model_c)
|
|
|
|
if not usebeta:beta,wb = "not used","not used"
|
|
vals = ""
|
|
modes=["Weight" ,"Add" ,"Triple","Twice"]
|
|
|
|
if "mbw" in xtype:
|
|
if "alpha" in xtype:wa = "X"
|
|
if usebeta or " beta" in xtype:wb = "X"
|
|
|
|
if "mbw" in ytype:
|
|
if "alpha" in ytype:wa = "Y"
|
|
if usebeta or " beta" in ytype:wb = "Y"
|
|
|
|
wa = "alpha = " + wa
|
|
wb = "beta = " + wb
|
|
|
|
x = 50
|
|
while len(wa) > x:
|
|
wa = wa[:x] + '\n' + wa[x:]
|
|
x = x + 50
|
|
|
|
x = 50
|
|
while len(wb) > x:
|
|
wb = wb[:x] + '\n' + wb[x:]
|
|
x = x + 50
|
|
|
|
if "model" in xtype:
|
|
if "A" in xtype:model_a = "model A"
|
|
elif "B" in xtype:model_b="model B"
|
|
elif "C" in xtype:model_c="model C"
|
|
|
|
if "model" in ytype:
|
|
if "A" in ytype:model_a = "model A"
|
|
elif "B" in ytype:model_b="model B"
|
|
elif "C" in ytype:model_c="model C"
|
|
|
|
if modes[1] in mode:
|
|
currentmodel =f"{model_a} \n {model_b} - {model_c})\n x alpha"
|
|
elif modes[2] in mode:
|
|
currentmodel =f"{model_a} x \n(1-alpha-beta) {model_b} x alpha \n+ {model_c} x beta"
|
|
elif modes[3] in mode:
|
|
currentmodel =f"({model_a} x(1-alpha) \n + {model_b} x alpha)*(1-beta)\n+ {model_c} x beta"
|
|
else:
|
|
currentmodel =f"{model_a} x (1-alpha) \n {model_b} x alpha"
|
|
|
|
if "alpha" in xtype:alpha = "X"
|
|
if "beta" in xtype:beta = "X"
|
|
if "alpha" in ytype:alpha = "Y"
|
|
if "beta" in ytype:beta = "Y"
|
|
|
|
if "mbw" in xtype:
|
|
if "alpha" in xtype: alpha = "X"
|
|
if "beta" in xtype or usebeta: beta = "X"
|
|
|
|
if "mbw" in ytype:
|
|
if "alpha" in ytype: alpha = "Y"
|
|
if "beta" in ytype or usebeta: beta = "Y"
|
|
|
|
vals = f"\nalpha = {alpha},beta = {beta}" if not useblocks else f"\n{wa}\n{wb}"
|
|
|
|
currentmodel = currentmodel+vals
|
|
return currentmodel
|
|
|
|
def effectivechecker(imgs,xs,ys,model_a,model_b,esettings):
|
|
diffs = []
|
|
outnum =[]
|
|
im1 = np.array(imgs[0])
|
|
|
|
model_a = filenamecutter(model_a)
|
|
model_b = filenamecutter(model_b)
|
|
dir = os.path.join(opts.outdir_txt2img_samples,f"{model_a+model_b}","difgif")
|
|
|
|
if "gif" in esettings:
|
|
try:
|
|
os.makedirs(dir)
|
|
except FileExistsError:
|
|
pass
|
|
|
|
ls,ss = (xs.copy(),ys.copy()) if len(xs) > len(ys) else (ys.copy(),xs.copy())
|
|
|
|
for i in range(len(imgs)-1):
|
|
im2 = np.array(imgs[i+1])
|
|
|
|
abs_diff = cv2.absdiff(im2 , im1)
|
|
|
|
abs_diff_t = cv2.threshold(abs_diff, 20, 255, cv2.THRESH_BINARY)[1]
|
|
res = abs_diff_t.astype(np.uint8)
|
|
percentage = (np.count_nonzero(res) * 100)/ res.size
|
|
abs_diff = cv2.bitwise_not(abs_diff)
|
|
outnum.append(percentage)
|
|
|
|
abs_diff = Image.fromarray(abs_diff)
|
|
|
|
diffs.append(abs_diff)
|
|
|
|
if "gif" in esettings:
|
|
gifpath = gifpath_t = os.path.join(dir,ls[i+1].replace(":","_")+".gif")
|
|
|
|
is_file = os.path.isfile(gifpath)
|
|
j = 0
|
|
while is_file:
|
|
gifpath = gifpath_t.replace(".gif",f"_{j}.gif")
|
|
print(gifpath)
|
|
is_file = os.path.isfile(gifpath)
|
|
j = j + 1
|
|
|
|
imgs[0].save(gifpath, save_all=True, append_images=[imgs[i+1]], optimize=False, duration=1000, loop=0)
|
|
|
|
nums = []
|
|
outs = []
|
|
|
|
ls = ls[1:]
|
|
for i in range(len(ls)):
|
|
nums.append([ls[i],outnum[i]])
|
|
ls[i] = ls[i] + "\n Diff : " + str(round(outnum[i],3)) + "%"
|
|
|
|
if "csv" in esettings:
|
|
try:
|
|
os.makedirs(dir)
|
|
except FileExistsError:
|
|
pass
|
|
filepath = os.path.join(dir, f"{model_a+model_b}.csv")
|
|
with open(filepath, "a", newline="") as f:
|
|
writer = csv.writer(f)
|
|
writer.writerows(nums)
|
|
|
|
if len(ys) > len (xs):
|
|
for diff,img in zip(diffs,imgs[1:]):
|
|
outs.append(diff)
|
|
outs.append(img)
|
|
outs.append(imgs[0])
|
|
ss = ["diff",ss[0],"source"]
|
|
return outs,ss,ls
|
|
else:
|
|
outs = [imgs[0]]*len(diffs) + imgs[1:]+ diffs
|
|
ss = ["source",ss[0],"diff"]
|
|
return outs,ls,ss
|
|
|
|
def crazyslot(lmode,lsets,llimits_u,llimits_l,lseed,lserial,lcustom,xtype,xmen,ytype,ymen,weights_a,weights_b,start):
|
|
if start == RAND:
|
|
if lserial > RANDCOL:
|
|
xtype = ytype = TYPES.index(RAND)
|
|
xmen = RANDCOL
|
|
ymen = lserial // RANDCOL + 1
|
|
else:
|
|
xtype = TYPES.index(RAND)
|
|
xmen = lserial
|
|
|
|
if "alpha" in lsets:
|
|
if "custom" in lmode:
|
|
weights_a = lcustom
|
|
else:
|
|
weights_a = ",".join([lmode]*26)
|
|
|
|
if "beta" in lsets:
|
|
if "custom" in lmode:
|
|
weights_b = lcustom
|
|
else:
|
|
weights_b = ",".join([lmode]*26)
|
|
|
|
return xtype,xmen,ytype,ymen,weights_a,weights_b
|
|
|
|
def alldealer(mens,types):
|
|
for i, men in enumerate(mens):
|
|
if men == "ALL":
|
|
if types[i] == "pinpoint blocks":mens[i] = "BASE,IN00,IN01,IN02,IN03,IN04,IN05,IN06,IN07,IN08,IN09,IN10,IN11,M00|OUT00,OUT01,OUT02,OUT03,OUT04,OUT05,OUT06,OUT07,OUT08,OUT09,OUT10,OUT11"
|
|
if types[i] == "pinpoint adjust":mens[i] ="IN,OUT,OUT2,CONT,COL1,COL2,COL3"
|
|
return mens
|
|
|
|
def draw_grid_annotations(im, width, height, hor_texts, ver_texts, margin=0):
|
|
|
|
color_active = ImageColor.getcolor(opts.grid_text_active_color, 'RGB')
|
|
color_inactive = ImageColor.getcolor(opts.grid_text_inactive_color, 'RGB')
|
|
color_background = ImageColor.getcolor(opts.grid_background_color, 'RGB')
|
|
|
|
def wrap(drawing, text, font, line_length):
|
|
lines = ['']
|
|
for word in text.split():
|
|
line = f'{lines[-1]} {word}'.strip()
|
|
if drawing.textlength(line, font=font) <= line_length:
|
|
lines[-1] = line
|
|
else:
|
|
lines.append(word)
|
|
return lines
|
|
|
|
def draw_texts(drawing, draw_x, draw_y, lines, initial_fnt, initial_fontsize):
|
|
minfont = 2244096
|
|
for line in lines:
|
|
fnt = initial_fnt
|
|
fontsize = initial_fontsize
|
|
line_spacing = fontsize // 2
|
|
while drawing.multiline_textsize(line.text, font=fnt,spacing = 5)[0] > line.allowed_width and fontsize > 0:
|
|
fontsize -= 1
|
|
fnt = get_font(fontsize)
|
|
line_spacing = fontsize // 2
|
|
if minfont > fontsize:
|
|
minfont = fontsize
|
|
|
|
fnt = get_font(minfont)
|
|
|
|
for line in lines:
|
|
drawing.multiline_text((draw_x, draw_y + line.size[1] / 2), line.text, font=fnt, fill=color_active if line.is_active else color_inactive, anchor="mm", align="center",spacing = 5)
|
|
|
|
if not line.is_active:
|
|
drawing.line((draw_x - line.size[0] // 2, draw_y + line.size[1] // 2, draw_x + line.size[0] // 2, draw_y + line.size[1] // 2), fill=color_inactive, width=4)
|
|
|
|
draw_y += line.size[1] * 0.3 + line_spacing
|
|
|
|
fontsize = (width + height) // 25
|
|
line_spacing = fontsize // 20
|
|
|
|
fnt = get_font(fontsize)
|
|
|
|
pad_left = 0 if sum([sum([len(line.text) for line in lines]) for lines in ver_texts]) == 0 else width * 3 // 4
|
|
|
|
cols = im.width // width
|
|
rows = im.height // height
|
|
|
|
assert cols == len(hor_texts), f'bad number of horizontal texts: {len(hor_texts)}; must be {cols}'
|
|
assert rows == len(ver_texts), f'bad number of vertical texts: {len(ver_texts)}; must be {rows}'
|
|
|
|
calc_img = Image.new("RGB", (1, 1), color_background)
|
|
calc_d = ImageDraw.Draw(calc_img)
|
|
|
|
for texts, allowed_width in zip(hor_texts + ver_texts, [width] * len(hor_texts) + [pad_left] * len(ver_texts)):
|
|
items = [] + texts
|
|
texts.clear()
|
|
|
|
for line in items:
|
|
wrapped = wrap(calc_d, line.text, fnt, allowed_width)
|
|
texts += [images.GridAnnotation(x, line.is_active) for x in wrapped]
|
|
|
|
for line in texts:
|
|
bbox = calc_d.multiline_textbbox((0, 0), line.text, font=fnt)
|
|
line.size = (bbox[2] - bbox[0], bbox[3] - bbox[1])
|
|
line.allowed_width = allowed_width
|
|
|
|
hor_text_heights = [sum([line.size[1] + line_spacing for line in lines]) - line_spacing for lines in hor_texts]
|
|
ver_text_heights = [sum([line.size[1] + line_spacing for line in lines]) - line_spacing * len(lines) for lines in ver_texts]
|
|
|
|
pad_top = 0 if sum(hor_text_heights) == 0 else max(hor_text_heights) + line_spacing * 2
|
|
|
|
result = Image.new("RGB", (im.width + pad_left + margin * (cols-1), im.height + pad_top + margin * (rows-1)), color_background)
|
|
|
|
for row in range(rows):
|
|
for col in range(cols):
|
|
cell = im.crop((width * col, height * row, width * (col+1), height * (row+1)))
|
|
result.paste(cell, (pad_left + (width + margin) * col, pad_top + (height + margin) * row))
|
|
|
|
d = ImageDraw.Draw(result)
|
|
|
|
for col in range(cols):
|
|
x = pad_left + (width + margin) * col + width / 2
|
|
y = pad_top / 2 - hor_text_heights[col] / 2
|
|
|
|
draw_texts(d, x, y, hor_texts[col], fnt, fontsize)
|
|
|
|
for row in range(rows):
|
|
x = pad_left / 2
|
|
y = pad_top + (height + margin) * row + height / 2 - ver_text_heights[row] / 2
|
|
|
|
draw_texts(d, x, y, ver_texts[row], fnt, fontsize)
|
|
|
|
return result
|
|
|
|
def mainmodeldealer(xyz):
|
|
abc = [True,True,True]
|
|
if "model" in xyz:
|
|
if "A" in xyz:abc[0] = False
|
|
if "B" in xyz:abc[1] = False
|
|
if "C" in xyz:abc[2] = False
|
|
return abc
|