Upload scripts using SD-Hub extension

scripts/CFG Auto.py

@@ -0,0 +1,368 @@
+#CFG Scheduler for Automatic1111 Stable Diffusion web-ui
+#Author: https://github.com/guzuligo/
+#Based on: https://github.com/tkalayci71/attenuate-cfg-scale
+#Version: 1.81
+
+from logging import PlaceHolder
+import math
+import os
+import sys
+import traceback
+import copy
+import numpy as np
+import modules.scripts as scripts
+import gradio as gr
+
+#from modules.processing import Processed, process_images
+from modules import images,processing
+from modules.processing import process_images, Processed
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+class Script(scripts.Script):
+    def run(self,p,n0,dns,ns1,ns2,nr1,nr2   ,loops,nSingle):
+        return self.runBasic(p,n0,dns,ns1,ns2,nr1,nr2   ,loops,nSingle)
+
+    #def run(self,p,cfg,eta,dns ,loops,nSingle):
+    #    return self.runAdvanced(p,cfg,eta,dns ,loops,nSingle)
+
+    def show(self, is_img2img):
+        self.isAdvanced=False
+        return True
+    def title(self):
+        return "CFG Scheduling" if (self.isAdvanced) else "CFG Auto"
+
+    def uiAdvanced(self, is_img2img):
+
+        placeholder="The steps on which to modify, in format step:value - example: 0:10 ; 10:15"
+        n0 = gr.Textbox(label="CFG",placeholder=placeholder)
+        placeholder="You can also use functions like: 0: math.fabs(-t) ; 1: (1-t/T) ; 2:=e ;3:t*d"
+        n1 = gr.Textbox(label="ETA",placeholder=placeholder)
+        #loops
+        #n2 = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=1)
+        n2 = gr.Slider(minimum=0, maximum=1, step=0.01, label='Target Denoising : Decay per Batch', value=0.5)
+        with gr.Row():
+            loops=gr.Number(value=1,precision=0,label="loops")
+            nSingle= gr.Checkbox(label="Loop returns one")
+            
+        return [n0,n1,n2    ,loops,nSingle]
+    #uiBasic
+    def uiAuto(self, is_img2img):
+        self.autoOptions={"b1":"Blur First V1","b2":"Blur Last","f1":"Force at Start V1","f2":"Force Allover"}
+        with gr.Row():
+            dns = gr.Slider(minimum=0, maximum=1, step=0.01, label='Target Denoising : Decay per Batch', value=0.25)
+            n0=gr.Dropdown(list(self.autoOptions.values()),value=self.autoOptions["b1"],label="Scheduler")
+        with gr.Row():
+            n1 = gr.Slider(minimum=0, maximum=100, step=1, label='Main Strength', value=10)
+            n2 = gr.Slider(minimum=0, maximum=100, step=1, label='Sub- Strength', value=10)
+        with gr.Row():
+            n3 = gr.Slider(minimum=0, maximum=100, step=1, label='Main Range', value=10)
+            n4 = gr.Slider(minimum=0, maximum=100, step=1, label='Sub- Range', value=10)
+        with gr.Row():
+            loops=gr.Number(value=1,precision=0,label="loops")
+            nSingle= gr.Checkbox(label="Loop returns one")
+        return [n0,dns,   n1,n2,n3,n4   ,loops,nSingle]
+
+    def ui(self, is_img2img):
+        return self.uiAdvanced(is_img2img) if (self.isAdvanced) else self.uiAuto(is_img2img)
+
+    def prepare(self,p,cfg,eta):
+        sampler_name=p.sampler_name
+        if not sampler_name:
+            print("Warning: sampler not specified. Using Euler a")
+            sampler_name="Euler a"
+        #if p.sampler_index in (0,1,2,7,8,10,14):
+        if sampler_name in ('Euler a','Euler','LMS','DPM++ 2M','DPM fast','LMS Karras','DPM++ 2M Karras'):
+            max_mul_count = p.steps * p.batch_size
+            steps_per_mul = p.batch_size
+        #elif p.sampler_index in (3,4,5,6,11,12,13):
+        elif sampler_name in ('Heun','DPM2','DPM2 a','DPM++ 2S a','DPM2 Karras','DPM2 a Karras','DPM++ 2S a Karras'):
+            max_mul_count = ((p.steps*2)-1) * p.batch_size
+            steps_per_mul = 2 * p.batch_size
+        #elif p.sampler_index==15: # ddim
+        elif sampler_name=='DDIM': # ddim
+            max_mul_count = fix_ddim_step_count(p.steps)
+            steps_per_mul = 1
+        #elif p.sampler_index==16: # plms
+        elif sampler_name=='PLMS': # plms
+            max_mul_count = fix_ddim_step_count(p.steps)+1
+            steps_per_mul = 1
+        else:
+            print("Not supported sampler", p.sampler_name, p.sampler_index)
+            return # 9=dpm adaptive
+
+        
+
+        #print("it is:",n0t)
+        #for x in range(int(n)):
+        self.p=p
+        cfg=cfg.strip()
+        eta=eta.strip()
+        if cfg:
+            p.cfg_scale=Fake_float(p.cfg_scale,self.split(cfg,str(p.cfg_scale))  , max_mul_count, steps_per_mul)
+            #p.cfg_scale.p=p
+        if eta:
+            if (eta.find("@")==-1):
+                p.s_churn=p.eta    =Fake_float(p.eta     or 1,self.split(eta,str(p.eta))    , max_mul_count, steps_per_mul)
+                #print(p.s_noise)
+            
+                #Fake_float(p.s_churn or 1,self.split(eta,str(p.s_churn)), max_mul_count, steps_per_mul)
+            else:
+                eta=eta.split("@")
+                if eta[0].strip()!="":
+                    p.s_churn=Fake_float(p.s_churn or 1,self.split(eta[0],str(p.s_churn)), max_mul_count, steps_per_mul)
+                if len(eta)>1 and eta[1].strip()!="":
+                    p.s_noise=Fake_float(p.s_noise or 1,self.split(eta[1],str(p.s_noise)), max_mul_count, steps_per_mul)
+                if len(eta)>2 and eta[2].strip()!="":
+                    p.s_tmin=Fake_float(p.s_tmin or 1,self.split(eta[2],str(p.s_tmin)), max_mul_count, steps_per_mul)
+                if len(eta)>3 and eta[3].strip()!="":
+                    p.s_tmax=Fake_float(p.s_tmax or 1,self.split(eta[2],str(p.s_tmax)), max_mul_count, steps_per_mul)
+
+
+            #p.cfg_scale.p=p
+        #
+
+
+
+    def runBasic(self,p,n0,dns,ns1,ns2,nr1,nr2  ,loops,nSingle):
+        if(n0==self.autoOptions["b1"]):
+            cfg=f"""0:{ns2}/2 if (t<T* (({nr1}/100)**2)) else cfg"""
+            eta=f"""0:{ns1}+1 if (t<T*(({nr1}/100)**2)  ) else e*({nr2}/50)"""
+        elif(n0==self.autoOptions["f1"]):
+            cfg=f"""0:({ns1}*4)*((1-d**0.5)**1.5)/(t*(30-cfg)/30+1)/(l*2+1) 	if (t<T*{nr1}/100) else 0.1 if (t<T*({nr1}+{nr2}-{nr1}*{nr2})/100) else 7-d*7"""
+            eta=f"""0:0.8+{ns2}/25-min(t*0.1, 0.8+{ns2}/25 -0.01)			if (t<T*{nr1}/100) else {ns2}/(10*(1+l*0.5)) if (t<T*({nr1}+{nr2}-{nr1}*{nr2})/100) else 1+e"""
+        elif(n0==self.autoOptions["b2"]):
+            cfg=f"""0:cfg if (e>{nr1}/100 or e<(1-({nr1}+{nr2}*(100-{nr1})/100)/100)) else {ns2}/10"""
+            eta=f"""0:e   if (e>{nr1}/100 or e<(1-({nr1}+{nr2}*(100-{nr1})/100)/100)) else {ns1}/10"""
+        elif(n0==self.autoOptions["f2"]):
+            cfg=f"""= min(40,max(0,cfg+x(t)*({ns2}-50)/2 )) """
+            eta=f"""0:(1-(t%(2+  10-.1*{nr1}  ))/ (2+10-.1*{nr1}) )*{ns1}*.1  * (e*(100-{nr2})+{nr2})*.01 """
+        self.cfgsib={"Scheduler":n0,'Main Strength':ns1,'Sub- Strength':ns2,'Main Range':nr1,'Sub- Range':nr2}
+        return self.runAdvanced(p,cfg,eta,dns   ,loops,nSingle)
+
+
+    def runAdvanced(self, p, cfg,eta,dns    ,loops,nSingle):
+        self.initSeed=p.seed
+        #loops=p.batch_size
+        loops = loops if (loops>0) else 1
+
+        batch_count=p.n_iter
+        state.job_count = loops*p.n_iter
+        p.denoising_strength=p.denoising_strength or (1 if (self.isAdvanced) else 0.2)
+        initial_denoising_strength=p.denoising_strength
+        p.do_not_save_grid = True
+        if hasattr(p,"init_images"):
+            original_init_image = p.init_images
+            initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+        else:
+            original_init_image=None
+        
+        all_images = []
+        cfgsi=" loops:"+str(loops)+" terget denoising: "+str(dns)+"\nCFG: "+cfg+"\nETA: "+eta+"\n"
+        
+        p.extra_generation_params = {
+                "CFG Scheduler Info":cfgsi,
+            } 
+        
+
+        #if basic, add basic info as well
+        if (self.isAdvanced==False):
+            self.cfgsib.update(p.extra_generation_params)
+            p.extra_generation_params=self.cfgsib
+
+        if loops>1:
+            processing.fix_seed(p)
+            #self.initDenoise=p.denoising_strength
+            
+        for n in range(batch_count):
+            proc=None
+            history = []
+            p.denoising_strength=initial_denoising_strength
+            if (original_init_image!=None):
+                p.init_images=original_init_image
+            for loop in range(loops):
+                if opts.img2img_color_correction and original_init_image!=None:
+                        p.color_corrections = initial_color_corrections
+
+                p.batch_size = 1
+                p.n_iter = 1
+                self.loop=loop
+                self.prepare(p, cfg,eta)
+                proc = process_images(p)
+                if loop==0:
+                    self.initInfo=proc.info
+                    self.initSeed=proc.seed
+                if len(proc.images)>0:
+                    history.append(proc.images[0])
+                    p.seed+=1
+                    p.init_images=[proc.images[0]]
+                    #p.denoising_strength=min(max(p.denoising_strength * dns, 0.05), 1)
+                    p.denoising_strength=initial_denoising_strength+(dns-initial_denoising_strength)*(loop+1)/(loops)
+                else:#interrupted
+                    break
+                #print("New denoising:"+str(p.denoising_strength)+"\n" )
+            all_images += history
+        if loops>0:#TODO:maybe this is not needed
+            p.seed=self.initSeed
+        #return proc if (loops==1 and p.batch_size==1) else Processed(p, all_images, self.initSeed, self.initInfo)
+        return proc if(nSingle) else Processed(p, all_images, self.initSeed, self.initInfo)
+
+
+
+
+
+
+
+    def peek(self,val):
+        print(val)
+        return val
+
+    def split(self,src,default='0'):
+        p=self.p
+        self.P=copy.copy({
+            'cfg':float(str(p.cfg_scale)),
+            'd':p.denoising_strength or 1,
+            'l':self.loop,
+            'min':min,
+            'max':max,
+            'abs':abs,
+            'pow':pow,
+            'pi':math.pi,
+            'x':self._interpolate,
+            'int':int,
+            'floor':math.floor,
+            'peek':self.peek,
+        })
+
+        if src[0:4]=="eval":
+            src="0:"+src[4:]
+        if src[0]=="=":
+            src="0:"+src[1:]
+
+        #clean up
+        while src[len(src)-1] in [";"," "]:
+            src=src[0:len(src)-1]
+        while src[0] in [";"," "]:
+            src=src[1:]
+
+        arr0 = src.split(';')##2
+
+        #resort array accounting for commas in indecies
+        arr=[]
+        for j in arr0:
+            #print(j)
+            v=j.split(":")
+            q=v[0].split(",")
+                
+            for i in q:
+                arr.append(i+":"+v[1])
+
+                
+
+
+        arr.sort(key=self._sort)
+        s=[]
+        val=default
+        for j in range(p.steps+1):
+          i=0
+          while i<len(arr) and i<=j:
+              v=arr[i].split(":")
+              #s=proc[j].n_iter
+              if math.floor(int(v[0]) if v[0].isnumeric() else float(v[0])*p.steps)==j:
+                 val=v[1].strip()
+                 break
+              i=i+1
+              
+          #lets just evaluate all        
+          if val[0]=="=":
+            val=val[1:]
+          
+          _eta=1-j/p.steps
+          params={'t':j,'T':p.steps,'math':math,'p':p,'e':float(str(_eta))}
+          
+          params.update(copy.copy(self.P))
+          #print(params)
+          s.append(float(eval(val,params)))
+          #end while loop
+          #else:    
+            #s.append(float(val))
+        print(np.round(s,1),"\n")
+        return s
+    #limits a range of a value
+    def _interpolate(self,v,start=0,end=None,m=1):
+        end=end or self.p.steps
+        v=min(max(v,start),end)-start
+        return v*m/(end-start)+(1 if m<0 else 0)
+
+    def _sort(self,a):
+        _=a.split(":")[0]#splitter tester
+        return math.floor(int(_) if (_.isnumeric()) else float(_)*self.p.steps)
+
+    def evaluate (self,src):
+        s=[]
+        p=self.p
+        T=self.p.steps
+        for j in range(T+1):
+            _eta=1-j/p.steps
+            params={'t':j,'T':p.steps,'math':math,'p':p,'e':_eta}
+            params.update(self.P)
+            s.append(float(eval(src,params)))
+        return s
+
+class Fake_float(float):
+    def __new__(self, value, arr, max_mul_count, steps_per_mul):
+        return float.__new__(self, value)
+
+    def __init__(self, value, arr, max_mul_count, steps_per_mul):
+        float.__init__(value)
+        self.arr = arr
+        self.curstep = 0
+        #self.p=p
+
+        #self.orig_value = orig_value
+        #self.target_value = target_value
+        self.max_mul_count = max_mul_count
+        self.current_mul = 0
+        self.steps_per_mul = steps_per_mul
+        self.current_step = 0 #fake
+        self.max_step_count = (max_mul_count // steps_per_mul) + (max_mul_count % steps_per_mul > 0)
+
+
+    def __mul__(self,other):
+        return self.fake_mul(other)
+
+    def __rmul__(self,other):
+        return self.fake_mul(other)
+
+    #def __add__(self,other):
+        #print("ADD!")
+    #    return self.get_fake_value(other)+other
+    #def __sub__(self,other):
+        #print("SUB!")
+    #    return self.get_fake_value(other)-other
+
+
+
+    def fake_mul(self,other):
+        #print("MUL!")
+        return self.get_fake_value(other) * other
+
+
+    def get_fake_value(self,other):
+        if (self.max_step_count==1):
+            fake_value = self.arr[0]
+        else:
+           
+            fake_value = self.arr[self.curstep]
+        self.current_mul = (self.current_mul+1) % self.max_mul_count
+        self.curstep = (self.current_mul) // self.steps_per_mul
+        self.current_step+=1#FAKE STEP
+        return fake_value
+
+    
+
+
+def fix_ddim_step_count(steps):
+    valid_step = 999 / (1000 // steps)
+    if valid_step == int(valid_step): steps=int(valid_step)+1
+    if ((1000 % steps)!=0): steps +=1
+    return steps

scripts/CFG Schedule.py

@@ -0,0 +1,369 @@
+#CFG Scheduler for Automatic1111 Stable Diffusion web-ui
+#Author: https://github.com/guzuligo/
+#Based on: https://github.com/tkalayci71/attenuate-cfg-scale
+#Version: 1.81
+
+from logging import PlaceHolder
+import math
+import os
+import sys
+import traceback
+import copy
+import numpy as np
+import modules.scripts as scripts
+import gradio as gr
+
+#from modules.processing import Processed, process_images
+from modules import images,processing
+from modules.processing import process_images, Processed
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+class Script(scripts.Script):
+    #def run(self,p,n0,dns,ns1,ns2,nr1,nr2   ,loops,nSingle):
+    #    return self.runBasic(p,n0,dns,ns1,ns2,nr1,nr2   ,loops,nSingle)
+
+    def run(self,p,cfg,eta,dns ,loops,nSingle):
+        return self.runAdvanced(p,cfg,eta,dns ,loops,nSingle)
+
+    def show(self, is_img2img):
+        self.isAdvanced=True
+        return True
+    def title(self):
+        return "CFG Scheduling" if (self.isAdvanced) else "CFG Auto"
+
+    def uiAdvanced(self, is_img2img):
+
+        placeholder="The steps on which to modify, in format step:value - example: 0:10 ; 10:15"
+        n0 = gr.Textbox(label="CFG",placeholder=placeholder)
+        placeholder="You can also use functions like: 0: math.fabs(-t) ; 1: (1-t/T) ; 2:=e ;3:t*d"
+        n1 = gr.Textbox(label="ETA",placeholder=placeholder)
+        #loops
+        #n2 = gr.Slider(minimum=1, maximum=32, step=1, label='Loops', value=1)
+        n2 = gr.Slider(minimum=0, maximum=1, step=0.01, label='Target Denoising : Decay per Batch', value=0.5)
+        with gr.Row():
+            loops=gr.Number(value=1,precision=0,label="loops")
+            nSingle= gr.Checkbox(label="Loop returns one")
+            
+        return [n0,n1,n2    ,loops,nSingle]
+    #uiBasic
+    def uiAuto(self, is_img2img):
+        self.autoOptions={"b1":"Blur First V1","b2":"Blur Last","f1":"Force at Start V1","f2":"Force Allover"}
+        with gr.Row():
+            dns = gr.Slider(minimum=0, maximum=1, step=0.01, label='Target Denoising : Decay per Batch', value=0.25)
+            n0=gr.Dropdown(list(self.autoOptions.values()),value=self.autoOptions["b1"],label="Scheduler")
+        with gr.Row():
+            n1 = gr.Slider(minimum=0, maximum=100, step=1, label='Main Strength', value=10)
+            n2 = gr.Slider(minimum=0, maximum=100, step=1, label='Sub- Strength', value=10)
+        with gr.Row():
+            n3 = gr.Slider(minimum=0, maximum=100, step=1, label='Main Range', value=10)
+            n4 = gr.Slider(minimum=0, maximum=100, step=1, label='Sub- Range', value=10)
+        with gr.Row():
+            loops=gr.Number(value=1,precision=0,label="loops")
+            nSingle= gr.Checkbox(label="Loop returns one")
+        return [n0,dns,   n1,n2,n3,n4   ,loops,nSingle]
+
+    def ui(self, is_img2img):
+        return self.uiAdvanced(is_img2img) if (self.isAdvanced) else self.uiAuto(is_img2img)
+
+    def prepare(self,p,cfg,eta):
+        sampler_name=p.sampler_name
+        if not sampler_name:
+            print("Warning: sampler not specified. Using Euler a")
+            sampler_name="Euler a"
+        #if p.sampler_index in (0,1,2,7,8,10,14):
+        if sampler_name in ('Euler a','Euler','LMS','DPM++ 2M','DPM fast','LMS Karras','DPM++ 2M Karras'):
+            max_mul_count = p.steps * p.batch_size
+            steps_per_mul = p.batch_size
+        #elif p.sampler_index in (3,4,5,6,11,12,13):
+        elif sampler_name in ('Heun','DPM2','DPM2 a','DPM++ 2S a','DPM2 Karras','DPM2 a Karras','DPM++ 2S a Karras'):
+            max_mul_count = ((p.steps*2)-1) * p.batch_size
+            steps_per_mul = 2 * p.batch_size
+        #elif p.sampler_index==15: # ddim
+        elif sampler_name=='DDIM': # ddim
+            max_mul_count = fix_ddim_step_count(p.steps)
+            steps_per_mul = 1
+        #elif p.sampler_index==16: # plms
+        elif sampler_name=='PLMS': # plms
+            max_mul_count = fix_ddim_step_count(p.steps)+1
+            steps_per_mul = 1
+        else:
+            print("Not supported sampler", p.sampler_name, p.sampler_index)
+            return # 9=dpm adaptive
+
+        
+
+        #print("it is:",n0t)
+        #for x in range(int(n)):
+        self.p=p
+        cfg=cfg.strip()
+        eta=eta.strip()
+        if cfg:
+            p.cfg_scale=Fake_float(p.cfg_scale,self.split(cfg,str(p.cfg_scale))  , max_mul_count, steps_per_mul)
+            #p.cfg_scale.p=p
+        if eta:
+            if (eta.find("@")==-1):
+                p.s_churn=p.eta    =Fake_float(p.eta     or 1,self.split(eta,str(p.eta))    , max_mul_count, steps_per_mul)
+                #print(p.s_noise)
+            
+                #Fake_float(p.s_churn or 1,self.split(eta,str(p.s_churn)), max_mul_count, steps_per_mul)
+            else:
+                eta=eta.split("@")
+                if eta[0].strip()!="":
+                    p.s_churn=Fake_float(p.s_churn or 1,self.split(eta[0],str(p.s_churn)), max_mul_count, steps_per_mul)
+                if len(eta)>1 and eta[1].strip()!="":
+                    p.s_noise=Fake_float(p.s_noise or 1,self.split(eta[1],str(p.s_noise)), max_mul_count, steps_per_mul)
+                if len(eta)>2 and eta[2].strip()!="":
+                    p.s_tmin=Fake_float(p.s_tmin or 1,self.split(eta[2],str(p.s_tmin)), max_mul_count, steps_per_mul)
+                if len(eta)>3 and eta[3].strip()!="":
+                    p.s_tmax=Fake_float(p.s_tmax or 1,self.split(eta[2],str(p.s_tmax)), max_mul_count, steps_per_mul)
+
+
+            #p.cfg_scale.p=p
+        #
+
+
+
+    def runBasic(self,p,n0,dns,ns1,ns2,nr1,nr2  ,loops,nSingle):
+        if(n0==self.autoOptions["b1"]):
+            cfg=f"""0:{ns2}/2 if (t<T* (({nr1}/100)**2)) else cfg"""
+            eta=f"""0:{ns1}+1 if (t<T*(({nr1}/100)**2)  ) else e*({nr2}/50)"""
+        elif(n0==self.autoOptions["f1"]):
+            cfg=f"""0:({ns1}*4)*((1-d**0.5)**1.5)/(t*(30-cfg)/30+1)/(l*2+1) 	if (t<T*{nr1}/100) else 0.1 if (t<T*({nr1}+{nr2}-{nr1}*{nr2})/100) else 7-d*7"""
+            eta=f"""0:0.8+{ns2}/25-min(t*0.1, 0.8+{ns2}/25 -0.01)			if (t<T*{nr1}/100) else {ns2}/(10*(1+l*0.5)) if (t<T*({nr1}+{nr2}-{nr1}*{nr2})/100) else 1+e"""
+        elif(n0==self.autoOptions["b2"]):
+            cfg=f"""0:cfg if (e>{nr1}/100 or e<(1-({nr1}+{nr2}*(100-{nr1})/100)/100)) else {ns2}/10"""
+            eta=f"""0:e   if (e>{nr1}/100 or e<(1-({nr1}+{nr2}*(100-{nr1})/100)/100)) else {ns1}/10"""
+        elif(n0==self.autoOptions["f2"]):
+            cfg=f"""= min(40,max(0,cfg+x(t)*({ns2}-50)/2 )) """
+            eta=f"""0:(1-(t%(2+  10-.1*{nr1}  ))/ (2+10-.1*{nr1}) )*{ns1}*.1  * (e*(100-{nr2})+{nr2})*.01 """
+        self.cfgsib={"Scheduler":n0,'Main Strength':ns1,'Sub- Strength':ns2,'Main Range':nr1,'Sub- Range':nr2}
+        self.cfgsib={"Scheduler":n0,'Main Strength':ns1,'Sub- Strength':ns2,'Main Range':nr1,'Sub- Range':nr2}
+        return self.runAdvanced(p,cfg,eta,dns   ,loops,nSingle)
+
+
+    def runAdvanced(self, p, cfg,eta,dns    ,loops,nSingle):
+        self.initSeed=p.seed
+        #loops=p.batch_size
+        loops = loops if (loops>0) else 1
+
+        batch_count=p.n_iter
+        state.job_count = loops*p.n_iter
+        p.denoising_strength=p.denoising_strength or (1 if (self.isAdvanced) else 0.2)
+        initial_denoising_strength=p.denoising_strength
+        p.do_not_save_grid = True
+        if hasattr(p,"init_images"):
+            original_init_image = p.init_images
+            initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+        else:
+            original_init_image=None
+        
+        all_images = []
+        cfgsi=" loops:"+str(loops)+" terget denoising: "+str(dns)+"\nCFG: "+cfg+"\nETA: "+eta+"\n"
+        
+        p.extra_generation_params = {
+                "CFG Scheduler Info":cfgsi,
+            } 
+        
+
+        #if basic, add basic info as well
+        if (self.isAdvanced==False):
+            self.cfgsib.update(p.extra_generation_params)
+            p.extra_generation_params=self.cfgsib
+
+        if loops>1:
+            processing.fix_seed(p)
+            #self.initDenoise=p.denoising_strength
+            
+        for n in range(batch_count):
+            proc=None
+            history = []
+            p.denoising_strength=initial_denoising_strength
+            if (original_init_image!=None):
+                p.init_images=original_init_image
+            for loop in range(loops):
+                if opts.img2img_color_correction and original_init_image!=None:
+                        p.color_corrections = initial_color_corrections
+
+                p.batch_size = 1
+                p.n_iter = 1
+                self.loop=loop
+                self.prepare(p, cfg,eta)
+                proc = process_images(p)
+                if loop==0:
+                    self.initInfo=proc.info
+                    self.initSeed=proc.seed
+                if len(proc.images)>0:
+                    history.append(proc.images[0])
+                    p.seed+=1
+                    p.init_images=[proc.images[0]]
+                    #p.denoising_strength=min(max(p.denoising_strength * dns, 0.05), 1)
+                    p.denoising_strength=initial_denoising_strength+(dns-initial_denoising_strength)*(loop+1)/(loops)
+                else:#interrupted
+                    break
+                #print("New denoising:"+str(p.denoising_strength)+"\n" )
+            all_images += history
+        if loops>0:#TODO:maybe this is not needed
+            p.seed=self.initSeed
+        #return proc if (loops==1 and p.batch_size==1) else Processed(p, all_images, self.initSeed, self.initInfo)
+        return proc if(nSingle) else Processed(p, all_images, self.initSeed, self.initInfo)
+
+
+
+
+
+
+
+    def peek(self,val):
+        print(val)
+        return val
+
+    def split(self,src,default='0'):
+        p=self.p
+        self.P=copy.copy({
+            'cfg':float(str(p.cfg_scale)),
+            'd':p.denoising_strength or 1,
+            'l':self.loop,
+            'min':min,
+            'max':max,
+            'abs':abs,
+            'pow':pow,
+            'pi':math.pi,
+            'x':self._interpolate,
+            'int':int,
+            'floor':math.floor,
+            'peek':self.peek,
+        })
+
+        if src[0:4]=="eval":
+            src="0:"+src[4:]
+        if src[0]=="=":
+            src="0:"+src[1:]
+
+        #clean up
+        while src[len(src)-1] in [";"," "]:
+            src=src[0:len(src)-1]
+        while src[0] in [";"," "]:
+            src=src[1:]
+
+        arr0 = src.split(';')##2
+
+        #resort array accounting for commas in indecies
+        arr=[]
+        for j in arr0:
+            #print(j)
+            v=j.split(":")
+            q=v[0].split(",")
+                
+            for i in q:
+                arr.append(i+":"+v[1])
+
+                
+
+
+        arr.sort(key=self._sort)
+        s=[]
+        val=default
+        for j in range(p.steps+1):
+          i=0
+          while i<len(arr) and i<=j:
+              v=arr[i].split(":")
+              #s=proc[j].n_iter
+              if math.floor(int(v[0]) if v[0].isnumeric() else float(v[0])*p.steps)==j:
+                 val=v[1].strip()
+                 break
+              i=i+1
+              
+          #lets just evaluate all        
+          if val[0]=="=":
+            val=val[1:]
+          
+          _eta=1-j/p.steps
+          params={'t':j,'T':p.steps,'math':math,'p':p,'e':float(str(_eta))}
+          
+          params.update(copy.copy(self.P))
+          #print(params)
+          s.append(float(eval(val,params)))
+          #end while loop
+          #else:    
+            #s.append(float(val))
+        print(np.round(s,1),"\n")
+        return s
+    #limits a range of a value
+    def _interpolate(self,v,start=0,end=None,m=1):
+        end=end or self.p.steps
+        v=min(max(v,start),end)-start
+        return v*m/(end-start)+(1 if m<0 else 0)
+
+    def _sort(self,a):
+        _=a.split(":")[0]#splitter tester
+        return math.floor(int(_) if (_.isnumeric()) else float(_)*self.p.steps)
+
+    def evaluate (self,src):
+        s=[]
+        p=self.p
+        T=self.p.steps
+        for j in range(T+1):
+            _eta=1-j/p.steps
+            params={'t':j,'T':p.steps,'math':math,'p':p,'e':_eta}
+            params.update(self.P)
+            s.append(float(eval(src,params)))
+        return s
+
+class Fake_float(float):
+    def __new__(self, value, arr, max_mul_count, steps_per_mul):
+        return float.__new__(self, value)
+
+    def __init__(self, value, arr, max_mul_count, steps_per_mul):
+        float.__init__(value)
+        self.arr = arr
+        self.curstep = 0
+        #self.p=p
+
+        #self.orig_value = orig_value
+        #self.target_value = target_value
+        self.max_mul_count = max_mul_count
+        self.current_mul = 0
+        self.steps_per_mul = steps_per_mul
+        self.current_step = 0 #fake
+        self.max_step_count = (max_mul_count // steps_per_mul) + (max_mul_count % steps_per_mul > 0)
+
+
+    def __mul__(self,other):
+        return self.fake_mul(other)
+
+    def __rmul__(self,other):
+        return self.fake_mul(other)
+
+    #def __add__(self,other):
+        #print("ADD!")
+    #    return self.get_fake_value(other)+other
+    #def __sub__(self,other):
+        #print("SUB!")
+    #    return self.get_fake_value(other)-other
+
+
+
+    def fake_mul(self,other):
+        #print("MUL!")
+        return self.get_fake_value(other) * other
+
+
+    def get_fake_value(self,other):
+        if (self.max_step_count==1):
+            fake_value = self.arr[0]
+        else:
+           
+            fake_value = self.arr[self.curstep]
+        self.current_mul = (self.current_mul+1) % self.max_mul_count
+        self.curstep = (self.current_mul) // self.steps_per_mul
+        self.current_step+=1#FAKE STEP
+        return fake_value
+
+    
+
+
+def fix_ddim_step_count(steps):
+    valid_step = 999 / (1000 // steps)
+    if valid_step == int(valid_step): steps=int(valid_step)+1
+    if ((1000 % steps)!=0): steps +=1
+    return steps

scripts/ContorlNet_I2I_sequence_toyxyz_V2.py

@@ -0,0 +1,367 @@
+import copy
+import os
+import shutil
+
+import cv2
+import gradio as gr
+import numpy as np
+import modules.scripts as scripts
+
+from modules import images, processing
+from modules.processing import process_images, Processed
+from modules.shared import opts
+from PIL import Image, ImageFilter, ImageColor, ImageOps
+from pathlib import Path
+from typing import List, Tuple, Iterable
+
+
+#Returns a list of images located in the input path. For ControlNet iamges
+def get_all_frames_from_path(path):
+    if not os.path.isdir(path):
+        return None
+    frame_list = []
+    for filename in sorted(os.listdir(path)):
+        if filename.endswith(".jpg") or filename.endswith(".png"):
+            img_path = os.path.join(path, filename)
+            img = cv2.imread(img_path)
+            if img is not None:
+                frame_list.append(img)
+    frame_list.insert(0, frame_list[0])            
+    return frame_list  
+    
+
+#Returns a list of images located in the input path. For Color iamges
+def get_images_from_path(path):
+    if not os.path.isdir(path):
+        return None
+    images = []
+    for filename in os.listdir(path):
+        if filename.endswith('.jpg') or filename.endswith('.png'):
+            img_path = os.path.join(path, filename)
+            img = Image.open(img_path)
+            images.append(img)
+    images.append(images[-1])
+    images.insert(0, images[0])
+    return images
+
+#Returns the number of the smallest number in the entire image sequence list. For ControlNet
+def get_min_frame_num(video_list):
+    min_frame_num = -1
+    for video in video_list:
+        if video is None:
+            continue
+        else:
+            frame_num = len(video)
+            print(frame_num)
+            if min_frame_num < 0:
+                min_frame_num = frame_num
+            elif frame_num < min_frame_num:
+                min_frame_num = frame_num
+    return min_frame_num
+
+
+#Blende method
+
+
+def basic(target, blend, opacity):
+    return target * opacity + blend * (1-opacity)
+
+def blender(func):
+    def blend(target, blend, opacity=1, *args):
+        res = func(target, blend, *args)
+        res = basic(res, blend, opacity)
+        return np.clip(res, 0, 1)
+    return blend
+
+
+class Blend:
+    @classmethod
+    def method(cls, name):
+        return getattr(cls, name)
+    
+    normal = basic
+    
+    @staticmethod
+    @blender
+    def darken(target, blend, *args):
+        return np.minimum(target, blend)
+    
+    @staticmethod
+    @blender
+    def multiply(target, blend, *args):
+        return target * blend
+    
+    @staticmethod
+    @blender
+    def color_burn(target, blend, *args):
+        return 1 - (1-target)/blend
+    
+    @staticmethod
+    @blender
+    def linear_burn(target, blend, *args):
+        return target+blend-1
+    
+    @staticmethod
+    @blender
+    def lighten(target, blend, *args):
+        return np.maximum(target, blend)
+    
+    @staticmethod
+    @blender
+    def screen(target, blend, *args):
+        return 1 - (1-target) * (1-blend)
+    
+    @staticmethod
+    @blender
+    def color_dodge(target, blend, *args):
+        return target/(1-blend)
+    
+    @staticmethod
+    @blender
+    def linear_dodge(target, blend, *args):
+        return target+blend
+    
+    @staticmethod
+    @blender
+    def overlay(target, blend, *args):
+        return  (target>0.5) * (1-(2-2*target)*(1-blend)) +\
+                (target<=0.5) * (2*target*blend)
+    
+    @staticmethod
+    @blender
+    def soft_light(target, blend, *args):
+        return  (blend>0.5) * (1 - (1-target)*(1-(blend-0.5))) +\
+                (blend<=0.5) * (target*(blend+0.5))
+    
+    @staticmethod
+    @blender
+    def hard_light(target, blend, *args):
+        return  (blend>0.5) * (1 - (1-target)*(2-2*blend)) +\
+                (blend<=0.5) * (2*target*blend)
+    
+    @staticmethod
+    @blender
+    def vivid_light(target, blend, *args):
+        return  (blend>0.5) * (1 - (1-target)/(2*blend-1)) +\
+                (blend<=0.5) * (target/(1-2*blend))
+    
+    @staticmethod
+    @blender
+    def linear_light(target, blend, *args):
+        return  (blend>0.5) * (target + 2*(blend-0.5)) +\
+                (blend<=0.5) * (target + 2*blend)
+    
+    @staticmethod
+    @blender
+    def pin_light(target, blend, *args):
+        return  (blend>0.5) * np.maximum(target,2*(blend-0.5)) +\
+                (blend<=0.5) * np.minimum(target,2*blend)
+    
+    @staticmethod
+    @blender
+    def difference(target, blend, *args):
+        return np.abs(target - blend)
+    
+    @staticmethod
+    @blender
+    def exclusion(target, blend, *args):
+        return 0.5 - 2*(target-0.5)*(blend-0.5)
+
+blend_methods = [i for i in Blend.__dict__.keys() if i[0]!='_' and i!='method']
+
+
+
+def blend_images(base_img, blend_img, blend_method, blend_opacity, do_invert):
+    
+    img_base = np.array(base_img.convert("RGB")).astype(np.float64)/255
+    
+    if do_invert:
+        img_to_blend = ImageOps.invert(blend_img.convert('RGB'))       
+    else:
+        img_to_blend = blend_img
+                
+    img_to_blend = img_to_blend.resize((int(base_img.width), int(base_img.height)))
+                
+    img_to_blend = np.array(img_to_blend.convert("RGB")).astype(np.float64)/255
+            
+    img_blended = Blend.method(blend_method)(img_to_blend, img_base, blend_opacity)
+                
+    img_blended *= 255
+                
+    img_blended = Image.fromarray(img_blended.astype(np.uint8), mode='RGB')
+    
+    return img_blended
+
+
+#Define UI and script properties.
+class Script(scripts.Script):  
+    
+    def title(self):
+        return "controlnet I2I sequence_toyxyz_v2"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+
+        ctrls_group = ()
+        max_models = opts.data.get("control_net_max_models_num", 1)
+        
+        input_list = []
+
+        with gr.Group():
+            with gr.Accordion("ControlNet-I2I-sequence-toyxyz", open = True): 
+                with gr.Column():
+                                    
+                    feed_prev_frame = gr.Checkbox(value=False, label="Feed previous frame / Reduce flickering by feeding the previous frame image generated by Img2Img")
+                    
+                    use_init_img = gr.Checkbox(value=False, label="Blend color image / Blend the color image sequence with the initial Img2Img image or previous frame")
+                    
+                    use_TemporalNet = gr.Checkbox(value=False, label="Use TemporalNet / Using TemporalNet to reduce flicker between image sequences. Add TemporalNet in addition to the multi-controlnet you need. It should be placed at the end of the controlnet list.")
+
+                    blendmode = gr.Dropdown(blend_methods, value='normal', label='Blend mode / Choose how to blend the color image with the Previous frame or Img2Img initial image')
+                    
+                    opacityvalue = gr.Slider(0, 1, value=0, label="Opacity / Previous frame or Img2Img initial image + (color image * opacity)", info="Choose betwen 0 and 1")
+                    
+
+                    for i in range(max_models):
+                        input_path = gr.Textbox(label=f"ControlNet-{i}", placeholder="image sequence path")
+                        input_list.append(input_path)
+                    
+                    tone_image_path = gr.Textbox(label=f"Color_Image / Color images to be used for Img2Img in sequence", placeholder="image sequence path")
+                    
+                    output_path = gr.Textbox(label=f"Output_path / Deletes the contents located in the path, and creates a new path if it does not exist", placeholder="Output path")
+
+        ctrls_group += tuple(input_list) + (use_TemporalNet, use_init_img, opacityvalue, blendmode, feed_prev_frame, tone_image_path, output_path)
+
+        return ctrls_group
+        
+
+
+    #Image Generate Definition
+    def run(self, p, *args):
+
+        path = p.outpath_samples
+        
+        output_path = args[-1]  # get the last argument, which is the output path
+        
+        feedprev = args[-3]
+        
+        blendm = args[-4]
+        
+        opacityval = args[-5]
+        
+        useinit = args[-6]
+
+        usetempo = args[-7]
+        
+        
+        # Check whether the output path exists, if it does, delete it and create a new one.
+        if os.path.isdir(output_path):
+            for file in os.scandir(output_path):
+                os.remove(file.path)
+        else :    
+            os.mkdir(output_path)
+
+        #Get the number of controlnet models.
+        video_num = opts.data.get("control_net_max_models_num", 1)
+
+        # Get the ControlNet image sequence list.
+        image_list = [get_all_frames_from_path(image) for image in args[:video_num]]
+        
+        # Get a list of color image sequences.
+        color_image_list = get_images_from_path(args[-2])
+        
+        # Get the first frame
+        previmg = p.init_images
+
+        tempoimg = p.init_images[0]
+        
+        #If img2img color correction is enabled in webui settings, color correction is performed based on the first frame.
+        initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+        
+        #Save initial img2img image
+        initial_image = p.init_images[0]
+        
+        # Get the total number of frames.
+        frame_num = get_min_frame_num(image_list)
+
+        # image processing
+        if frame_num > 0:
+            output_image_list = []
+            
+            for frame in range(frame_num):
+                copy_p = copy.copy(p)
+                copy_p.control_net_input_image = []
+                for video in image_list:
+                    if video is None:
+                        continue
+                    copy_p.control_net_input_image.append(video[frame])
+
+                    if usetempo == True :
+                        copy_p.control_net_input_image.append(tempoimg)
+
+                    
+                    if color_image_list and feedprev == False:
+                        
+                        if frame<len(color_image_list):
+                            tone_image = color_image_list[frame+1]
+                        
+                        if useinit:
+                            tone_image = blend_images(initial_image, tone_image, blendm, opacityval, False)
+                            
+                        p.init_images = [tone_image.convert("RGB")]
+                        
+                proc = process_images(copy_p) 
+                
+                
+                
+                if feedprev == True and useinit == False:
+                    if previmg is None:
+                        continue
+                    else:
+                        previmg = proc.images[0]
+                        
+                        if frame == 0:
+                            previmg = initial_image
+                            
+                        p.init_images = [previmg]
+                        
+                        if opts.img2img_color_correction:
+                            p.color_corrections = initial_color_corrections
+                            
+                            
+                if feedprev == True and color_image_list and useinit:
+                    if previmg is None:
+                        continue
+                    else:
+                        previmg = proc.images[0]
+                        
+                        if frame == 0:
+                            previmg = initial_image
+                            
+                        previmg = blend_images(previmg, color_image_list[frame+1], blendm, opacityval, False)
+
+                            
+                        p.init_images = [previmg]
+
+                        if opts.img2img_color_correction:
+                            p.color_corrections = initial_color_corrections
+
+                img = proc.images[0]
+
+                if usetempo == True :
+                    if frame > 0 :
+                        tempoimg = proc.images[0]
+
+
+                #Save image
+                if(frame>0):
+                    images.save_image(img, output_path, f"Frame_{frame}")
+                copy_p.close()
+                
+
+        else:
+            proc = process_images(p)
+        
+        return proc

scripts/LoopbackWave.py

@@ -0,0 +1,348 @@
+import os
+import platform
+import numpy as np
+from tqdm import trange
+import math
+import subprocess as sp
+import string
+import random
+from functools import reduce
+import re
+
+import modules.scripts as scripts
+import gradio as gr
+
+from datetime import datetime
+from modules import processing, shared, sd_samplers, images
+from modules.processing import Processed
+from modules.sd_samplers import samplers
+from modules.shared import opts, cmd_opts, state
+import subprocess
+
+
+wave_completed_regex = r'@wave_completed\(([\-]?[0-9]*\.?[0-9]+), ?([\-]?[0-9]*\.?[0-9]+)\)'
+wave_remaining_regex = r'@wave_remaining\(([\-]?[0-9]*\.?[0-9]+), ?([\-]?[0-9]*\.?[0-9]+)\)'
+
+def run_cmd(cmd):
+    cmd = list(map(lambda arg: str(arg), cmd))
+    print("Executing %s" % " ".join(cmd))
+    popen_params = {"stdout": sp.DEVNULL, "stderr": sp.PIPE, "stdin": sp.DEVNULL}
+
+    if os.name == "nt":
+       popen_params["creationflags"] = 0x08000000
+
+    proc = sp.Popen(cmd, **popen_params)
+    out, err = proc.communicate()  # proc.wait()
+    proc.stderr.close()
+
+    if proc.returncode:
+        raise IOError(err.decode("utf8"))
+
+    del proc
+
+def encode_video(input_pattern, starting_number, output_dir, fps, quality, encoding, create_segments, segment_duration, ffmpeg_path):
+    two_pass = (encoding == "VP9 (webm)")
+    alpha_channel = ("webm" in encoding)
+    suffix = "webm" if "webm" in encoding else "mp4"
+    output_location = output_dir + f".{suffix}"
+
+    encoding_lib = {
+      "VP9 (webm)": "libvpx-vp9",
+      "VP8 (webm)": "libvpx",
+      "H.264 (mp4)": "libx264",
+      "H.265 (mp4)": "libx265",
+    }[encoding]
+
+    args = [
+        "-framerate", fps,
+        "-start_number", int(starting_number),
+        "-i", input_pattern, 
+        "-c:v", encoding_lib, 
+        "-b:v","0", 
+        "-crf", quality,
+        ]
+
+    if encoding_lib == "libvpx-vp9":
+        args += ["-pix_fmt", "yuva420p"]
+        
+    if(ffmpeg_path == ""):
+        ffmpeg_path = "ffmpeg"
+        if(platform.system == "Windows"):
+            ffmpeg_path += ".exe"
+
+    print("\n\n")
+    if two_pass:
+        first_pass_args = args + [
+            "-pass", "1",
+            "-an", 
+            "-f", "null",
+            os.devnull
+        ]
+
+        second_pass_args = args + [
+            "-pass", "2",
+            output_location
+        ]
+
+        print("Running first pass ffmpeg encoding")       
+
+        run_cmd([ffmpeg_path] + first_pass_args)
+        print("Running second pass ffmpeg encoding.  This could take awhile...")
+        run_cmd([ffmpeg_path] + second_pass_args)
+    else:
+        print("Running ffmpeg encoding.  This could take awhile...")
+        run_cmd([ffmpeg_path] + args + [output_location])
+
+    if(create_segments):
+      print("Segmenting video")
+      run_cmd([ffmpeg_path] + [
+          "-i", output_location,
+          "-f", "segment",
+          "-segment_time", segment_duration,
+          "-vcodec", "copy",
+          "-acodec", "copy",
+          f"{output_dir}.%d.{suffix}"
+      ])
+      
+def set_weights(match_obj, wave_progress):
+  weight_0 = 0
+  weight_1 = 0
+  if match_obj.group(1) is not None:
+    weight_0 = float(match_obj.group(1))
+  if match_obj.group(2) is not None:
+    weight_1 = float(match_obj.group(2))
+    
+  max_weight = max(weight_0, weight_1)
+  min_weight = min(weight_0, weight_1)
+  
+  weight_range = max_weight - min_weight
+  weight = min_weight + weight_range * wave_progress
+  return str(weight)
+
+
+class Script(scripts.Script):
+    def title(self):
+        return "Loopback Wave V1.4.1"
+
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        frames = gr.Slider(minimum=1, maximum=2048, step=1, label='Frames', value=100)
+        frames_per_wave = gr.Slider(minimum=0, maximum=120, step=1, label='Frames Per Wave', value=20)
+        denoising_strength_change_amplitude = gr.Slider(minimum=0, maximum=1, step=0.01, label='Max additional denoise', value=0.6)
+        denoising_strength_change_offset = gr.Number(minimum=0, maximum=180, step=1, label='Wave offset (ignore this if you don\'t know what it means)', value=0)
+        initial_image_number = gr.Number(minimum=0, label='Initial generated image number', value=0)
+
+        save_prompts = gr.Checkbox(label='Save prompts as text file', value=True)
+        prompts = gr.Textbox(label="Prompt Changes", lines=5, value="")
+
+        save_video = gr.Checkbox(label='Save results as video', value=True)
+        output_dir = gr.Textbox(label="Video Name", lines=1, value="")
+        video_fps = gr.Slider(minimum=1, maximum=120, step=1, label='Frames per second', value=10)
+        video_quality = gr.Slider(minimum=0, maximum=60, step=1, label='Video Quality (crf)', value=40)
+        video_encoding = gr.Dropdown(label='Video encoding', value="VP9 (webm)", choices=["VP9 (webm)", "VP8 (webm)", "H.265 (mp4)", "H.264 (mp4)"])
+        ffmpeg_path = gr.Textbox(label="ffmpeg binary.  Only set this if it fails otherwise.", lines=1, value="")
+
+        segment_video = gr.Checkbox(label='Cut video in to segments', value=True)
+        video_segment_duration = gr.Slider(minimum=10, maximum=60, step=1, label='Video Segment Duration (seconds)', value=20)
+
+
+        return [frames, denoising_strength_change_amplitude, frames_per_wave, denoising_strength_change_offset,initial_image_number, prompts, save_prompts, save_video, output_dir, video_fps, video_quality, video_encoding, ffmpeg_path, segment_video, video_segment_duration]
+
+    def run(self, p, frames, denoising_strength_change_amplitude, frames_per_wave, denoising_strength_change_offset, initial_image_number, prompts: str,save_prompts, save_video, output_dir, video_fps, video_quality, video_encoding, ffmpeg_path, segment_video, video_segment_duration):
+        processing.fix_seed(p)
+        batch_count = p.n_iter
+        p.extra_generation_params = {
+            "Max Additional Denoise": denoising_strength_change_amplitude,
+            "Frames per wave": frames_per_wave,
+            "Wave Offset": denoising_strength_change_offset,
+        }
+
+        # We save them ourselves for the sake of ffmpeg
+        p.do_not_save_samples = True
+
+        changes_dict = {}
+
+
+        p.batch_size = 1
+        p.n_iter = 1
+
+        output_images, info = None, None
+        initial_seed = None
+        initial_info = None
+
+        grids = []
+        all_images = []
+        original_init_image = p.init_images
+        state.job_count = frames * batch_count
+
+        initial_color_corrections = [processing.setup_color_correction(p.init_images[0])]
+        initial_denoising_strength = p.denoising_strength
+
+        if(output_dir==""):
+            output_dir = str(p.seed)
+        else:
+            output_dir = output_dir + "-" + str(p.seed)
+
+        loopback_wave_path = os.path.join(p.outpath_samples, "loopback-wave")
+        loopback_wave_images_path = os.path.join(loopback_wave_path, output_dir)
+
+        os.makedirs(loopback_wave_images_path, exist_ok=True)
+
+        p.outpath_samples = loopback_wave_images_path
+        
+        prompts = prompts.strip()
+        
+        if save_prompts:
+            with open(loopback_wave_images_path + "-prompts.txt", "w") as f:
+                generation_settings = [
+                  "Generation Settings",
+                  f"Total Frames: {frames}",
+                  f"Frames Per Wave: {frames_per_wave}",
+                  f"Wave Offset: {denoising_strength_change_offset}",
+                  f"Base Denoising Strength: {initial_denoising_strength}",
+                  f"Max Additional Denoise: {denoising_strength_change_amplitude}",
+                  f"Initial Image Number: {initial_image_number}",
+                  "",
+                  "Video Encoding Settings",
+                  f"Save Video: {save_video}"
+                ]
+                
+                if save_video:
+                  generation_settings = generation_settings + [
+                    f"Framerate: {video_fps}",
+                    f"Quality: {video_quality}",
+                    f"Encoding: {video_encoding}",
+                    f"Create Segmented Video: {segment_video}"
+                  ]
+                  
+                  if segment_video:
+                    generation_settings = generation_settings + [f"Segment Duration: {video_segment_duration}"]
+                 
+                generation_settings = generation_settings + [
+                  "",
+                  "Prompt Details",
+                  "Initial Prompt:" + p.prompt,
+                  "",
+                  "Negative Prompt:" + p.negative_prompt,
+                  "",
+                  "Frame change prompts:",
+                  prompts
+                ]
+                  
+
+
+                f.write('\n'.join(generation_settings))
+
+        if prompts:
+            lines = prompts.split("\n")
+            for prompt_line in lines:
+              params = prompt_line.split("::")
+              if len(params) == 2:
+                changes_dict[params[0]] = { "prompt": params[1] }
+              elif len(params) == 3:
+                changes_dict[params[0]] = { "seed": params[1], "prompt": params[2] }
+              else:
+                raise IOError(f"Invalid input in prompt line: {prompt_line}")
+        
+        raw_prompt = p.prompt
+                
+        for n in range(batch_count):
+            history = []
+
+            # Reset to original init image at the start of each batch
+            p.init_images = original_init_image
+            
+            seed_state = "adding"
+            current_seed = p.seed
+
+            for i in range(frames):
+                current_seed = p.seed
+                state.job = ""
+                
+                if str(i) in changes_dict:
+                  raw_prompt = changes_dict[str(i)]["prompt"]
+                  state.job = "New prompt: %s\n" % raw_prompt
+                                    
+                  if "seed" in changes_dict[str(i)]:
+                    current_seed = changes_dict[str(i)]["seed"]
+                    
+                    if current_seed.startswith("+"):
+                      seed_state = "adding"
+                      current_seed = current_seed.strip("+")
+                    elif current_seed.startswith("-"):
+                      seed_state = "subtracting"
+                      current_seed = current_seed.strip("-")
+                    else:
+                      seed_state = "constant"
+                      
+                    current_seed = int(current_seed)
+                    p.seed = current_seed
+                      
+                      
+                  
+                p.n_iter = 1
+                p.batch_size = 1
+                p.do_not_save_grid = True
+
+                if opts.img2img_color_correction:
+                    p.color_corrections = initial_color_corrections
+                    
+                    
+                wave_progress = float(1)/(float(frames_per_wave - 1))*float(((float(i)%float(frames_per_wave)) + ((float(1)/float(180))*denoising_strength_change_offset)))
+                print(wave_progress)
+                new_prompt = re.sub(wave_completed_regex, lambda x: set_weights(x, wave_progress), raw_prompt)
+                new_prompt = re.sub(wave_remaining_regex, lambda x: set_weights(x, 1 - wave_progress), new_prompt)
+                p.prompt = new_prompt
+                
+                print(new_prompt)
+
+                denoising_strength_change_rate = 180/frames_per_wave
+
+                cos = abs(math.cos(math.radians(i*denoising_strength_change_rate + denoising_strength_change_offset)))
+                p.denoising_strength = initial_denoising_strength + denoising_strength_change_amplitude - (cos * denoising_strength_change_amplitude)
+
+                state.job += f"Iteration {i + 1}/{frames}, batch {n + 1}/{batch_count}. Denoising Strength: {p.denoising_strength}"
+
+                processed = processing.process_images(p)
+
+                if initial_seed is None:
+                    initial_seed = processed.seed
+                    initial_info = processed.info
+
+                init_img = processed.images[0]
+
+                p.init_images = [init_img]
+                
+                if seed_state == "adding":
+                  p.seed = processed.seed + 1
+                elif seed_state == "subtracting":
+                  p.seed = processed.seed - 1
+                  
+                image_number = int(initial_image_number + i)
+                images.save_image(init_img, p.outpath_samples, "", processed.seed, processed.prompt, forced_filename=str(image_number))
+
+                history.append(init_img)
+
+            grid = images.image_grid(history, rows=1)
+            if opts.grid_save:
+                images.save_image(grid, p.outpath_grids, "grid", initial_seed, p.prompt, opts.grid_format, info=info, short_filename=not opts.grid_extended_filename, grid=True, p=p)
+
+            grids.append(grid)
+            all_images += history
+
+        if opts.return_grid:
+            all_images = grids + all_images
+      
+        if save_video:
+            now = datetime.now() # get the current date and time
+            date_string = now.strftime("%Y-%m-%d")
+            input_pattern = os.path.join(loopback_wave_images_path, date_string,"%d.png")
+            encode_video(input_pattern, initial_image_number, loopback_wave_images_path, video_fps, video_quality, video_encoding, segment_video, video_segment_duration, ffmpeg_path)
+                    
+        processed = Processed(p, all_images, initial_seed, initial_info)
+
+        return processed
+
+

scripts/Txt2img2img2img.py

@@ -0,0 +1,291 @@
+from modules.shared import opts, cmd_opts, state
+from modules.processing import Processed, StableDiffusionProcessingImg2Img, process_images, images
+from modules import paths, shared, modelloader, sd_models
+from modules import sd_samplers
+from PIL import Image, ImageDraw
+import gradio as gr
+import modules.scripts as scripts
+from random import randint
+from skimage.util import random_noise
+from gradio.processing_utils import encode_pil_to_base64
+import numpy as np
+import os.path
+from copy import deepcopy
+def remap_range(value, minIn, MaxIn, minOut, maxOut):
+            if value > MaxIn: value = MaxIn;
+            if value < minIn: value = minIn;
+            if (MaxIn - minIn) == 0 : return maxOut
+            finalValue = ((value - minIn) / (MaxIn - minIn)) * (maxOut - minOut) + minOut;
+            return finalValue;
+
+class Script(scripts.Script):
+    def title(self):
+        return "Txt2img2img2img"
+
+    def ui(self, is_img2img):
+        if is_img2img: return
+
+        # samplers list
+        img2img_samplers_names = [s.name for s in sd_samplers.samplers_for_img2img]
+
+        # models list
+        model_dir = "Stable-diffusion"
+        model_path = os.path.abspath(os.path.join(paths.models_path, model_dir))
+        model_list = modelloader.load_models(model_path=model_path, command_path=shared.cmd_opts.ckpt_dir, ext_filter=[".ckpt", ".safetensors"], download_name="v1-5-pruned-emaonly.safetensors", ext_blacklist=[".vae.ckpt", ".vae.safetensors"])
+        model_list = [m.split("\\")[-1] for m in model_list]
+        model_list.append("Same")
+
+        t2iii_reprocess = gr.Slider(minimum=1, maximum=128, step=1, label='Number of img2img', value=1)
+        t2iii_steps = gr.Slider(minimum=1, maximum=120, step=1, label='img2img steps', value=24)
+        with gr.Row():
+            t2iii_cfg_scale = gr.Slider(minimum=1, maximum=30, step=0.1, label='img2img cfg scale ', value=8.3)
+            t2iii_cfg_scale_end = gr.Slider(minimum=0, maximum=30, step=0.1, label='img2img cfg end scale (0=disabled) ', value=0)
+        with gr.Row():
+            t2iii_denoising_strength = gr.Slider(minimum=0, maximum=1, step=0.01, label='img2img denoising strength ', value=0.42)
+            t2iii_patch_end_denoising = gr.Slider(minimum=0, maximum=1,  step=0.01, label='Last img denoising (0=disabled)', value=0)
+        t2iii_seed_shift = gr.Slider(minimum=-1, maximum=1000000, step=1, label='img2img new seed+ (-1 for random)', value=1)
+        with gr.Row():
+            t2iii_patch_upscale   = gr.Checkbox(label='Patch upscale', value=False)
+            t2iii_patch_shift     = gr.Checkbox(label='Patch upscale shift grid', value=True)
+            t2iii_save_first      = gr.Checkbox(label='Save first image', value=False)
+            t2iii_only_last       = gr.Checkbox(label='Only save last img2img', value=True)
+            t2iii_face_correction = gr.Checkbox(label='Face correction on all', value=False)
+            t2iii_face_correction_last = gr.Checkbox(label='Face correction on last', value=False)
+        with gr.Row():
+            t2iii_model   = gr.Dropdown(label="Model",   choices=model_list, value="Same")
+            t2iii_sampler = gr.Dropdown(label="Sampler", choices=img2img_samplers_names, value="DPM++ 2M")
+        # with gr.Row():
+        #     t2iii_override_s_noise = gr.Checkbox(label='Override sampler\'s noise for last pass', value=False)
+        #     t2iii_sampler_noise    = gr.Slider(minimum=0, maximum=1,  step=0.5, label='Sampler\'s noise for last pass', value=0)
+        with gr.Row():
+            t2iii_clip    = gr.Slider(minimum=0, maximum=12, step=1, label='change clip for img2img (0 = disabled)', value=0)
+            t2iii_noise   = gr.Slider(minimum=0, maximum=0.005,  step=0.0001, label='Add noise before img2img ', value=0)
+        with gr.Row():
+            t2iii_patch_square_size   = gr.Slider(minimum=64, maximum=2048,  step=64, label='Patch upscale square size', value=512)
+            t2iii_patch_padding       = gr.Slider(minimum=0, maximum=512,  step=8, label='Patch upscale padding', value=128)
+        with gr.Row():
+            t2iii_patch_border        = gr.Slider(minimum=0, maximum=64,   step=1, label='Patch upscale mask inner border', value=8)
+            t2iii_patch_mask_blur     = gr.Slider(minimum=0, maximum=64 ,  step=1, label='Patch upscale mask blur', value=4)
+        with gr.Row():
+            t2iii_upscale_x = gr.Slider(minimum=64, maximum=16384, step=64, label='img2img width (64 = no rescale) ', value=768)
+            t2iii_upscale_y = gr.Slider(minimum=64, maximum=16384, step=64, label='img2img height (64 = no rescale) ', value=960)
+        t2iii_2x_last = gr.Slider(minimum=1, maximum=4, step=0.1, label='resize time x size for last pass', value=1)
+        with gr.Row():
+            t2iii_replace_prompt  = gr.Checkbox(label='Replace the prompt', value=False)
+            t2iii_replace_negative_prompt  = gr.Checkbox(label='Replace the negative prompt', value=False)
+        add_to_prompt   = gr.Textbox(label="Add to prompt", lines=2, max_lines=2000)
+        add_to_negative_prompt   = gr.Textbox(label="Add to prompt", lines=2, max_lines=2000)
+
+        return    [t2iii_reprocess,t2iii_steps,t2iii_cfg_scale,t2iii_seed_shift,t2iii_denoising_strength,t2iii_patch_upscale,t2iii_patch_shift,t2iii_2x_last,t2iii_save_first,t2iii_only_last,t2iii_face_correction,t2iii_face_correction_last, t2iii_model, t2iii_sampler,t2iii_clip,t2iii_noise,t2iii_patch_padding,t2iii_patch_square_size,t2iii_patch_border,t2iii_patch_mask_blur,t2iii_patch_end_denoising,t2iii_upscale_x,t2iii_upscale_y,add_to_prompt,add_to_negative_prompt,t2iii_replace_prompt,t2iii_replace_negative_prompt,t2iii_cfg_scale_end]
+    def run(self,p,t2iii_reprocess,t2iii_steps,t2iii_cfg_scale,t2iii_seed_shift,t2iii_denoising_strength,t2iii_patch_upscale,t2iii_patch_shift,t2iii_2x_last,t2iii_save_first,t2iii_only_last,t2iii_face_correction,t2iii_face_correction_last, t2iii_model, t2iii_sampler,t2iii_clip,t2iii_noise,t2iii_patch_padding,t2iii_patch_square_size,t2iii_patch_border,t2iii_patch_mask_blur,t2iii_patch_end_denoising,t2iii_upscale_x,t2iii_upscale_y,add_to_prompt,add_to_negative_prompt,t2iii_replace_prompt,t2iii_replace_negative_prompt,t2iii_cfg_scale_end):
+        def add_noise_to_image(img,seed,t2iii_noise):
+            img = np.array(img)
+            img = random_noise(img, mode='gaussian', seed=proc.seed, clip=True, var=t2iii_noise)
+            img = np.array(255*img, dtype = 'uint8')
+            img = Image.fromarray(np.array(img))
+            return img
+        def create_mask(size, border_width):
+            im = Image.new('RGB', (size, size), color='white')
+            draw = ImageDraw.Draw(im)
+            draw.rectangle((0, 0, size, size), outline='black', width=border_width)
+            return im
+        def clean_model_name(model_name):
+            if "[" in model_name:
+                model_name = model_name.split(" ")[-2]
+            return model_name
+        def get_current_model_name():
+            return clean_model_name(shared.opts.sd_model_checkpoint)
+        def is_model_loaded(wanted):
+            return wanted == get_current_model_name()
+
+        img2img_samplers_names = [s.name for s in sd_samplers.samplers_for_img2img]
+        img2img_sampler_index = [i for i in range(len(img2img_samplers_names)) if img2img_samplers_names[i] == t2iii_sampler][0]
+
+
+
+        # models paths
+        model_dir = "Stable-diffusion"
+        model_path = os.path.abspath(os.path.join(paths.models_path, model_dir))
+        initial_model = get_current_model_name()
+        initial_model_path = os.path.abspath(os.path.join(model_path,initial_model))
+
+        secondary_model_name = clean_model_name(t2iii_model)
+        secondary_model_path = ""
+        if t2iii_model != "Same":
+            secondary_model_name = clean_model_name(t2iii_model)
+            secondary_model_path = os.path.abspath(os.path.join(model_path,secondary_model_name))
+
+
+
+        if p.seed == -1: p.seed = randint(0,1000000000)
+
+        initial_CLIP = opts.data["CLIP_stop_at_last_layers"]
+        p.do_not_save_samples = not t2iii_save_first
+        initial_prompt = deepcopy(p.prompt)
+        initial_negative_prompt = deepcopy(p.negative_prompt)
+
+        n_iter=p.n_iter
+        for j in range(n_iter):
+
+            if t2iii_model != "Same":
+                if not is_model_loaded(initial_model):
+                    print()
+                    sd_models.load_model(sd_models.CheckpointInfo(initial_model_path))
+
+            p.n_iter=1
+            if t2iii_clip > 0:
+                opts.data["CLIP_stop_at_last_layers"] = initial_CLIP
+
+            p.prompt = initial_prompt
+            p.negative_prompt = initial_negative_prompt
+
+            # PROCESS IMAGE
+            proc = process_images(p)
+
+            if add_to_prompt != "" or t2iii_replace_prompt:
+                if t2iii_replace_prompt:
+                    p.prompt = add_to_prompt
+                else:
+                    p.prompt = initial_prompt+add_to_prompt
+
+            if add_to_negative_prompt != "" or t2iii_replace_negative_prompt:
+                if t2iii_replace_negative_prompt:
+                    p.negative_prompt = add_to_negative_prompt
+                else:
+                    p.negative_prompt = initial_negative_prompt+add_to_negative_prompt
+
+            basename = ""
+            extra_gen_parms = {
+            'Initial steps':p.steps,
+            'Initial CFG scale':p.cfg_scale,
+            "Initial seed": p.seed,
+            'Initial sampler': p.sampler_name,
+            'Reprocess amount':t2iii_reprocess
+            }
+            for i in range(t2iii_reprocess):
+                if t2iii_upscale_x > 64:
+                    upscale_x = t2iii_upscale_x
+                else:
+                    upscale_x = p.width
+                if t2iii_upscale_y > 64:
+                    upscale_y = t2iii_upscale_y
+                else:
+                    upscale_y = p.height
+                if t2iii_2x_last > 1 and i+1 == t2iii_reprocess:
+                    upscale_x = int(upscale_x*t2iii_2x_last)
+                    upscale_y = int(upscale_y*t2iii_2x_last)
+                if t2iii_seed_shift == -1:
+                    reprocess_seed = randint(0,999999999)
+                else:
+                    reprocess_seed = p.seed+t2iii_seed_shift*(i+1)
+                if t2iii_clip > 0:
+                    opts.data["CLIP_stop_at_last_layers"] = t2iii_clip
+
+                if state.interrupted:
+                    if t2iii_clip > 0:
+                        opts.data["CLIP_stop_at_last_layers"] = initial_CLIP
+                    break
+
+                if t2iii_model != "Same":
+                    if not is_model_loaded(secondary_model_name):
+                        print()
+                        sd_models.load_model(sd_models.CheckpointInfo(secondary_model_path))
+
+                if i == 0:
+                    proc_temp = proc
+                else:
+                    proc_temp = proc2
+                if t2iii_noise > 0 :
+                    proc_temp.images[0] = add_noise_to_image(proc_temp.images[0],p.seed,t2iii_noise)
+
+                img2img_processing = StableDiffusionProcessingImg2Img(
+                    init_images=proc_temp.images,
+                    resize_mode=0,
+                    denoising_strength=remap_range(i,0,t2iii_reprocess-1,t2iii_denoising_strength,t2iii_patch_end_denoising) if t2iii_patch_end_denoising > 0 else t2iii_denoising_strength,
+                    mask=None,
+                    mask_blur=t2iii_patch_mask_blur,
+                    inpainting_fill=1,
+                    inpaint_full_res=False,
+                    inpaint_full_res_padding=0,
+                    inpainting_mask_invert=0,
+                    sd_model=p.sd_model,
+                    outpath_samples=p.outpath_samples,
+                    outpath_grids=p.outpath_grids,
+                    prompt=p.prompt,
+                    styles=p.styles,
+                    seed=reprocess_seed,
+                    subseed=proc_temp.subseed,
+                    subseed_strength=p.subseed_strength,
+                    seed_resize_from_h=p.seed_resize_from_h,
+                    seed_resize_from_w=p.seed_resize_from_w,
+                    #seed_enable_extras=p.seed_enable_extras,
+                    sampler_name=t2iii_sampler,
+                    #sampler_index=img2img_sampler_index,
+                    batch_size=p.batch_size,
+                    n_iter=p.n_iter,
+                    steps=t2iii_steps,
+                    cfg_scale=remap_range(i,0,t2iii_reprocess-1,t2iii_cfg_scale,t2iii_cfg_scale_end) if t2iii_cfg_scale_end > 0 else t2iii_cfg_scale,
+                    width=upscale_x,
+                    height=upscale_y,
+                    restore_faces=(t2iii_face_correction or (t2iii_face_correction_last and t2iii_reprocess-1 == i)) and not (t2iii_reprocess-1 == i and not t2iii_face_correction_last),
+                    tiling=p.tiling,
+                    do_not_save_samples=True,
+                    do_not_save_grid=p.do_not_save_grid,
+                    extra_generation_params=extra_gen_parms,
+                    overlay_images=p.overlay_images,
+                    negative_prompt=p.negative_prompt,
+                    eta=p.eta
+                    )
+                # if t2iii_reprocess-1 == i and t2iii_override_s_noise:
+                #         img2img_processing.s_noise = t2iii_sampler_noise
+                if not t2iii_patch_upscale:
+                    proc2 = process_images(img2img_processing)
+                    if ((t2iii_only_last and t2iii_reprocess-1 == i) or not t2iii_only_last):
+                        images.save_image(proc2.images[0], p.outpath_samples, "", proc_temp.seed, proc2.prompt, opts.samples_format, info=proc_temp.info, p=p)
+                else:
+                    proc_temp.images[0] = proc_temp.images[0].resize((upscale_x, upscale_y), Image.Resampling.LANCZOS)
+                    width_for_patch, height_for_patch = proc_temp.images[0].size
+                    real_square_size = int(t2iii_patch_square_size)
+                    overlap_pass = int(real_square_size/t2iii_reprocess)*i
+                    patch_seed = reprocess_seed
+                    for x in range(0, width_for_patch+overlap_pass if i>0 and t2iii_patch_shift else width_for_patch, real_square_size):
+                        for y in range(0, height_for_patch+overlap_pass if i>0 and t2iii_patch_shift else height_for_patch, real_square_size):
+                            if (
+                                x-overlap_pass > width_for_patch    or
+                                y-overlap_pass > height_for_patch   or
+                                x+real_square_size-overlap_pass < 0 or
+                                y+real_square_size-overlap_pass < 0
+                                ): continue
+                            if t2iii_seed_shift == -1:
+                                patch_seed = randint(0,999999999)
+                            else:
+                                patch_seed = patch_seed+t2iii_seed_shift
+                            patch = proc_temp.images[0].crop((x-t2iii_patch_padding-overlap_pass,
+                                                              y-t2iii_patch_padding-overlap_pass,
+                                                              x + real_square_size + t2iii_patch_padding-overlap_pass,
+                                                              y + real_square_size + t2iii_patch_padding-overlap_pass))
+                            img2img_processing.init_images = [patch]
+                            img2img_processing.do_not_save_samples = True
+                            img2img_processing.width  = patch.size[0]
+                            img2img_processing.height = patch.size[1]
+                            img2img_processing.seed   = patch_seed
+                            mask = create_mask(patch.size[0],t2iii_patch_padding+t2iii_patch_border)
+                            img2img_processing.image_mask = mask
+                            proc_patch_temp = process_images(img2img_processing)
+                            patch = proc_patch_temp.images[0]
+                            patch = patch.crop((t2iii_patch_padding, t2iii_patch_padding, patch.size[0] - t2iii_patch_padding, patch.size[1] - t2iii_patch_padding))
+                            proc_temp.images[0].paste(patch, (x-overlap_pass, y-overlap_pass))
+                    proc2 = proc_patch_temp
+                    proc2.images[0] = proc_temp.images[0]
+                    images.save_image(proc2.images[0], p.outpath_samples, "", proc2.seed, proc2.prompt, opts.samples_format, info=proc2.info, p=p)
+
+
+            p.subseed = p.subseed + 1 if p.subseed_strength  > 0 else p.subseed
+            p.seed    = p.seed    + 1 if p.subseed_strength == 0 else p.seed
+        if t2iii_model != "Same":
+            if not is_model_loaded(initial_model):
+                print()
+                sd_models.load_model(sd_models.CheckpointInfo(initial_model_path))
+        if t2iii_clip > 0:
+            opts.data["CLIP_stop_at_last_layers"] = initial_CLIP
+        return proc

scripts/UnsharpMask.py

@@ -0,0 +1,54 @@
+import modules.scripts as scripts
+import gradio as gr
+import os
+from modules import images
+from modules.processing import process_images, Processed
+from modules.processing import Processed
+from modules.shared import opts, cmd_opts, state
+
+class Script(scripts.Script):  
+
+   def title(self):
+     return "Unsharp Mask"
+
+#only show in img2img tab
+
+   def show(self, is_img2img):
+     return is_img2img
+
+#Gradio interface parameters 
+
+   def ui(self, is_img2img):
+     save = gr.Checkbox(False, label="Save original and effect")
+     umradius = gr.Slider(minimum=0.0, maximum=1000.0, step=1, value=0, label="Radius")
+     umpercent = gr.Slider(minimum=0.0, maximum=500.0, step=1, value=0, label="Percent")
+     umthreshold = gr.Slider(minimum=0.0, maximum=255.0, step=1, value=0, label="Threshold")
+     return [save, umradius, umpercent, umthreshold]
+
+#processed object
+   def run(self, p, save, umradius, umpercent, umthreshold):
+
+#perform unsharp mask operation
+     def unsharp_mask(im, umradius, umpercent, umthreshold):
+       from PIL import Image, ImageFilter
+       raf = im
+       raf = raf.filter(filter=ImageFilter.UnsharpMask(radius = umradius, percent = umpercent, threshold = umthreshold))
+       return raf
+
+# If save is off, save with prefix filename
+     basename = ""
+     if(save):
+       basename += "unsharpmask_"
+     else:
+       p.do_not_save_samples = True
+
+#process images
+     proc = process_images(p)
+
+     for i in range(len(proc.images)):
+
+       proc.images[i] = unsharp_mask(proc.images[i],  umradius, umpercent, umthreshold)
+       images.save_image(proc.images[i], p.outpath_samples, basename,
+       proc.seed + i, proc.prompt, opts.samples_format, info= proc.info, p=p)
+
+     return proc