fix:dk

compo-singleone-v2-dev-acc.py

@@ -27,6 +27,19 @@ import time
 import re
 
 
+SRV_TYPE="s1"
+
+#set env var RW_ if not already set
+if not os.getenv('RW_PORT'):
+    os.environ["RW_PORT"] = "7860"
+
+if not os.getenv('RW_DEBUG'):
+    os.environ["RW_DEBUG"] = "0"
+if not os.getenv('RW_HOST'):
+    os.environ["RW_HOST"] = "0.0.0.0"
+#RW_MODEL_OPTIONS
+if not os.getenv('RW_MODEL_OPTIONS'):
+    os.environ["RW_MODEL_OPTIONS"]='{"styleCheckpoint":"/data/styleCheckpoint"}'
 
 # Determining the size of the passes
 pass1_image_size = 1328
@@ -93,7 +106,9 @@ else:
 #######################################################
 
 def get_model_simplified_name_from_dirname(dirname):
-    return dirname.replace("model_","").replace("_864x","").replace("_864","").replace("_new","").replace("-864","")
+    result_simple_name = dirname.replace("model_","").replace("_864x","").replace("_864","").replace("_new","").replace("-864","")
+    print("   result_simple_name:" + result_simple_name)
+    return result_simple_name
 
 def get_padded_checkpoint_no_from_filename(checkpoint_filename):
     match = re.search(r'ckpt-(\d+)', checkpoint_filename)
@@ -138,7 +153,24 @@ def setup(opts):
     saver = tf.train.Saver()
     # saver2 = tf.train.Saver()
     # saver3 = tf.train.Saver()
-    path = opts['styleCheckpoint']
+    print("-------------====PATH---------------------->>>>--")
+    path_default = '/data/styleCheckpoint'
+    print("opts:")
+    print(opts)
+    print("----------------------------------------")
+    if opts is None:
+        print("ERROR:opts is None")
+        path = path_default
+    try:
+        path = opts['styleCheckpoint']
+    except:
+        opts= {'styleCheckpoint': u'/data/styleCheckpoint'}
+        path = opts['styleCheckpoint']
+    if not os.path.exists(path):
+        print("ERROR:Path does not exist:" + path)
+        path = path_default
+    print(path)
+    print("----------------PATH=======---------------<<<<--")
     #Getting the model name
     model_name = [p for p in os.listdir(path) if os.path.isdir(os.path.join(path, p))][0]    
     if not os.getenv('MODELNAME'):
@@ -170,13 +202,14 @@ def setup(opts):
     # checkpoint3_dir = os.path.join(path, model3_name, 'checkpoint_long')
     print("-----------------------------------------")
     print("modelname is : " + model_name)
+    
     found_model=get_model_simplified_name_from_dirname(model_name)
     
     #print("model2name is : " + model2_name)
     # print("model3name is : " + model3_name)
     print("checkpoint_dir is : " + checkpoint_dir)
 
-    print("Auto Brightness-Contrast Correction can be set as the x2 of this SingleOne Server")
+    
 
     
     #print("checkpoint2_dir is : " + checkpoint2_dir)
@@ -203,41 +236,131 @@ def setup(opts):
     # models.m3 = m3
     return models
 
-def _make_meta_as_json(inp):
+
+
+def make_target_output_filename(  mname,checkpoint, fn='',res1=0,abc=0, ext='.jpg',svrtype="s1", modelid='', suffix='', xtra_model_id='',verbose=False):
+    fn_base=fn.replace(ext,"")
+    fn_base=fn_base.replace(".jpg","")
+    fn_base=fn_base.replace(".jpeg","")
+    fn_base=fn_base.replace(".JPG","")
+    fn_base=fn_base.replace(".JPEG","")
+    fn_base=fn_base.replace(".png","")
+    fn_base=fn_base.replace(".PNG","")
+    
+    #pad res1 and res2 to 4 digits
+    res1_pad=str(res1).zfill(4)
+    
+    abc_pad=str(abc).zfill(2)
+    if res1_pad=="0000":
+        res1_pad=""
+        
+    
+    #pad checkpoint to 3 digits
+    checkpoint=checkpoint.zfill(3)
+    
+    if fn_base=="none":
+        fn_base=""
+    
+    if '/' in fn_base:
+        fn_base=fn_base.split('/')[-1]
+    # Print out all input info:
+    if verbose  :
+            
+        print("-----------------------------")
+        print("fn_base: ",fn_base)
+        print("mname: ",mname)
+        print("suffix: ",suffix)
+        print("res1: ",res1_pad)
+        print("abc: ",abc_pad)
+        print("ext: ",ext)
+        print("svrtype: ",svrtype)
+        print("modelid: ",modelid)
+        print("xtra_model_id: ",xtra_model_id)
+        print("checkpoint: ",checkpoint)
+        print("fn: ",fn)
+    
+    mtag = "{}__{}__{}x{}__{}__{}k".format(mname,suffix,res1_pad,abc_pad, svrtype, checkpoint).replace("_0x" + str(abc_pad), "")
+    if verbose:
+        print(mtag)
+    target_output = "{}__{}__{}{}{}".format(fn_base, modelid, mtag, xtra_model_id, ext).replace("_"+str(abc_pad)+"x"+str(abc_pad)+"_","").replace("_0x0_", "").replace("_0_", "").replace("_-", "_").replace("____", "__").replace("___", "__").replace("___", "__").replace("..",".").replace("model_","").replace("_x"+str(abc_pad)+"_","").replace("gia-ds-","")
+    target_output = replace_values_from_csv(target_output)
+
+    return target_output
+
+def replace_values_from_csv(target_output):
+    # Implement the logic to replace values from CSV
+    #load replacer.csv and replace the values (src,dst)
+    src_dest_file = 'replacer.csv'
+    if os.path.exists(src_dest_file):
+        with open(src_dest_file, 'r') as file:
+            lines = file.readlines()
+            for line in lines:
+                src, dst = line.split(',')
+                target_output = target_output.replace(src, dst)
+    return target_output.replace("\n", "").replace("\r", "").replace(" ", "_")
+    
+
+def _make_meta_as_json(x1=0,c1=0,inp=None,result_dict=None):
     global found_model,found_model_checkpoint
-    meta_value = inp['meta']
-    json_return = {
-        "meta": meta_value,
-        "model": found_model,
-        "checkpoint": found_model_checkpoint
-    }
-    return json_return
+    fn='none'
+    if inp['fn'] != 'none':
+        fn=inp['fn']
+    ext='.jpg'
+    if inp['ext'] != '.jpg':
+        ext=inp['ext']
+    
+    filename=make_target_output_filename(found_model,found_model_checkpoint,fn,x1,c1,ext,SRV_TYPE)
+    
+    if result_dict is None:
+        json_return = {
+            "model": str(found_model),
+            "checkpoint": str(found_model_checkpoint),
+            "filename": str(filename)
+        }
+        return json_return
+    else: #support adding to the existing dict the data directly
+        result_dict['model']=str(found_model)
+        result_dict['checkpoint']=str(found_model_checkpoint)
+        result_dict['filename']=str(filename)
+        return result_dict
+    
 
 
 meta_inputs={'meta':text}
-meta_outputs={'meta':text,'model':text,'files':text,'checkpoint':text}
+meta_outputs={'model':text,'filename':text,'checkpoint':text}
 
 @runway.command('meta2', inputs=meta_inputs, outputs=meta_outputs)
 def get_geta(models, inp):
     global found_model,found_model_checkpoint
     
-    json_return = _make_meta_as_json(inp)
+    json_return = _make_meta_as_json()
         # "files": "nothing yet"
     print(json_return)
     return json_return 
 
 
 
+@runway.command('meta', inputs=meta_inputs, outputs=meta_outputs)
+def get_geta(models, inp):
+    global found_model,found_model_checkpoint
+    
+    json_return = _make_meta_as_json(inp)
+        # "files": "nothing yet"
+    print(json_return)
+    return json_return 
+
+
 
 
 #@STCGoal add number or text to specify resolution of the three pass
-inputs={'contentImage': runway.image,'x1':number(default=1024,min=24,max=17000),'x2':number(default=0,min=-99,max=99)}
-outputs={'stylizedImage': runway.image,'totaltime':number,'x1': number,'c1':number,'model1name':text,'meta':text}
+inputs={'contentImage': runway.image,'x1':number(default=1024,min=24,max=18000),'c1':number(default=0,min=-99,max=99),'fn':text(default='none'),'ext':text(default='.jpg')}
+outputs={'stylizedImage': runway.image,'totaltime':number,'x1': number,'c1':number,'model1name':text,'checkpoint':text,'filename':text,'model':text}
 
 @runway.command('stylize', inputs=inputs, outputs=outputs)
 def stylize(models, inp):
+    global found_model,found_model_checkpoint,model1name
     start = time.time()
-    dtprint("Composing.1..")
+    
     model = models.m1
     #model2 = models.m2
     # model3 = models.m3
@@ -249,12 +372,9 @@ def stylize(models, inp):
     # m3name=models.m3.name
 
     #get size from inputs rather than env
-    x1 = inp['x1']
-    c1 = inp['x2']
-    # x3 = inp['x3']
-    if c1 > 99:
-        ci = abcdefault
-
+    x1 = int(inp['x1'])
+    
+    c1 = int(inp['c1'])
 
     #
     img = inp['contentImage']
@@ -266,7 +386,7 @@ def stylize(models, inp):
     image_size=x1
     img_shape = img.shape[:2]
     alpha = float(image_size) / float(min(img_shape))
-    dtprint ("DEBUG::content.imgshape:" +   str(tuple(img_shape)) + ", alpha:" + str(alpha))
+    #dtprint ("DEBUG::content.imgshape:" +   str(tuple(img_shape)) + ", alpha:" + str(alpha))
 
     try:
         img = scipy.misc.imresize(img, size=alpha)
@@ -278,7 +398,7 @@ def stylize(models, inp):
     #@a INFERENCE PASS 1
     dtprint("INFO:Pass1 inference starting")
     img = model['sess'].run(model['output_photo'], feed_dict={model['input_photo']: img})
-    dtprint("INFO:Pass1 inference done")
+    
     #
     img = (img + 1.) * 127.5
     img = img.astype('uint8')
@@ -339,18 +459,30 @@ def stylize(models, inp):
     # #pass3
 
     #dtprint("INFO:Composing done")
-    print('autoabc value:')
-    print(c1)
+
     if c1 != 0 :
-        print('Auto Brightening images...')
+        print('Auto Brightening images...' + str(c1))
         img = img, alpha2, beta = automatic_brightness_and_contrast(img,c1)
 
     stop = time.time()
     totaltime = stop - start
     print("The time of the run:", totaltime)
-    meta_data = _make_meta_as_json(inp)
-    res2 = dict(stylizedImage=img,totaltime=totaltime,x1=x1,model1name=model1name,c1=c1,meta=meta_data)
-    return res2
+    
+    #if model1name UNNAMED, use found_model
+    if model1name == "UNNAMED":
+        model1name=found_model
+    
+    include_meta_directly_in_result=True
+    
+    
+    if include_meta_directly_in_result:
+        result_dict = dict(stylizedImage=img,totaltime=totaltime,x1=x1,model1name=model1name,c1=c1)
+        result_dict = _make_meta_as_json(x1,c1,inp,result_dict)
+    else:
+        meta_data = _make_meta_as_json(x1,c1,inp)
+        result_dict = dict(stylizedImage=img,totaltime=totaltime,x1=x1,model1name=model1name,c1=c1,meta=meta_data)
+        
+    return result_dict