Info Display enhancement : Rotation, Rotation Speed, TimeDifference, Oriented Speed.

.gitignore

@@ -1 +1,25 @@
-/scripts/MKW_Inputs/*.csv
+scripts/MKW_Inputs/**/*.csv
+scripts/MKW_Inputs/**/*.rkg
+scripts/AGC_Data/**/*.agc
+scripts/external/**/*.ini
+scripts/Settings/**/*.ini
+scripts/FrameDumps/**/*.txt
+scripts/FrameDumps/**/*.rawtxt
+scripts/FrameDumps/**/*.ini
+scripts/FrameDumps/**/*.mp4
+scripts/FrameDumps/**/*.mp3
+scripts/FrameDumps/**/*.wav
+scripts/FrameDumps/*.png
+
+scripts/Data Dump/**
+/scripts/Ghost/**/*.rkg
+/scripts/Ghost/**/*.csv
+**/__pycache__
+**/*test*.py
+
+
+scripts/RMC/test.py
+scripts/RMC/test codecallbacl.py
+
+/scripts/Input_optimizer
+scripts/RMC/test tp lap.py

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "python.analysis.extraPaths": [
+        "./scripts/python-stubs"
+    ],
+    "editor.detectIndentation": false
+}

scripts/FrameDumps/Extra/author_display_util.py

@@ -0,0 +1,93 @@
+import moviepy
+import numpy as np
+from PIL import Image
+from PIL import ImageDraw
+from PIL import ImageFont
+import sys
+import os
+import time
+import subprocess
+import math
+
+from Extra import common
+
+def make_list_author(c, main_folder):
+    #return a dict so that result[frame] contain an ordered list of author that contributed on that frame
+    #also return a list of all author
+    result = {}
+    raw_author_list = []
+    author_file = os.path.join(main_folder, c.get('author_list_filename'))
+    if os.path.isfile(author_file):
+        with open(author_file, 'r', encoding='utf-8') as f:
+            entry_list = f.read().split('\n')
+            for entry in entry_list:
+                temp = entry.split(':')
+                author_name = temp[0]
+                raw_author_list.append(author_name) 
+                frames_entry = temp[1].split(',')
+                for token in frames_entry:
+                    temp = token.split('-')
+                    for frame in range(int(temp[0]), int(temp[-1])+1):
+                        if not frame in result.keys():
+                            result[frame] = []
+                        result[frame].append(author_name)
+    return raw_author_list, result
+
+
+def add_author_display(image, frame_dict, config, main_folder, raw_author_list, author_dict):
+    ad_config = config['Author display']
+    state, state_counter = int(frame_dict['state']), int(frame_dict['state_counter'])
+    author_display_layer = Image.new('RGBA', image.size, (0,0,0,0))
+    ID = ImageDraw.Draw(author_display_layer)
+    font_folder = os.path.join(main_folder, 'Fonts')
+    top_left_text = ad_config.get('top_left').split(',')
+    top_left = round(float(top_left_text[0])*image.width), round(float(top_left_text[1])*image.height)
+    font_size =  ad_config.getint('font_size')
+    font = ImageFont.truetype(os.path.join(font_folder, ad_config.get('font')), font_size)
+    active_text_color = common.get_color(ad_config.get('active_text_color'))
+    inactive_text_color = common.get_color(ad_config.get('inactive_text_color'))
+    outline_width = ad_config.getint('outline_width')
+    active_outline_color = common.get_color(ad_config.get('active_outline_color'))
+    inactive_outline_color = common.get_color(ad_config.get('inactive_outline_color'))
+    curframe = int(frame_dict['frame_of_input'])
+    spacing = 4
+    current_h = top_left[1]
+
+    for author_name in raw_author_list:
+        if curframe in author_dict.keys() and author_name in author_dict[curframe]:
+            ID.text( (top_left[0], current_h), author_name, fill = active_text_color, font = font, stroke_width = outline_width, stroke_fill = active_outline_color)
+        else:
+            ID.text( (top_left[0], current_h), author_name, fill = inactive_text_color , font = font, stroke_width = outline_width, stroke_fill = inactive_outline_color)
+        current_h += spacing + font_size
+
+
+    if ad_config.getboolean('fade_animation'):
+        author_display_layer = common.fade_image_manually(author_display_layer, frame_dict, ad_config)
+
+    # TODO
+    # if you change the delay to 0f (encoder line 97&98) the anim starts 1f early
+    # once shad's GUI is done, this can be parameterized easily. It's hard to notice so I didn't bother.
+
+    if ad_config.getboolean('fly_animation'):
+
+        if state == 1 and state_counter <= 10:
+            return None
+
+        offset = common.fly_in(frame_dict, image.height)
+        if state == 4 and 192 < state_counter <= 201:
+            image.alpha_composite(author_display_layer,  (round(0 - image.width*offset), 0))
+            return None
+
+        ITEM_POSITION = 381/1440
+        AUTHOR_DISPLAY_POSITION = (1 - float(top_left_text[1]))
+        height_correction =  round((AUTHOR_DISPLAY_POSITION - ITEM_POSITION)*image.height)
+
+        if offset is not None:
+            if ad_config.get('fly_in_direction') == 'bottom':
+                image.alpha_composite(author_display_layer, (0, image.height - top_left[1] - height_correction - offset))
+            else:
+                image.alpha_composite(author_display_layer, (0, offset - round(ITEM_POSITION*image.height)))
+        else:
+            image.alpha_composite(author_display_layer, (0,0))
+    else:
+        image.alpha_composite(author_display_layer, (0,0))

scripts/FrameDumps/Extra/common.py

@@ -0,0 +1,147 @@
+import moviepy
+import numpy as np
+from PIL import Image
+from PIL import ImageDraw
+from PIL import ImageFont
+from PIL import ImageFilter
+import sys
+import os
+import time
+import subprocess
+import math
+
+def get_color(color_text):
+    n = int(color_text, 16)
+    l = []
+    for _ in range(4):
+        l.append(n%256)
+        n//=256
+    l.reverse()
+    return tuple(l)
+
+def color_white_part(image, color):
+
+    if image.mode != 'RGBA':
+        image = image.convert('RGBA') #needed, crashes otherwise if image doesnt have transparency like analog_5_3_part1
+
+    color = tuple(color[:3])
+    pixels = image.load()
+    for y in range(image.height):
+        for x in range(image.width):
+            r, _, _, a = pixels[x, y]
+
+            if r == 255:
+                pixels[x, y] = (color[0], color[1], color[2], a)
+            else: 
+                brightness = r / 255
+                new_r = int(color[0] * brightness)
+                new_g = int(color[1] * brightness)
+                new_b = int(color[2] * brightness)
+                pixels[x, y] = (new_r, new_g, new_b, a)
+
+    return image
+
+def get_filter_list(config_text):
+    raw_list = config_text.split(',')
+    filters = []
+    for raw_text in raw_list:
+        if raw_text in ['BLUR', 'blur', 'Blur']:
+            filters.append(ImageFilter.BLUR)
+        elif raw_text in ['CONTOUR', 'contour', 'Countour']:
+            filters.append(ImageFilter.CONTOUR)
+        elif raw_text in ['DETAIL', 'detail', 'Detail']:
+            filters.append(ImageFilter.DETAIL)
+        elif raw_text in ['EDGE_ENHANCE', 'Edge_enhance', 'edge_enhance', 'Edge_Enhance']:
+            filters.append(ImageFilter.EDGE_ENHANCE)
+        elif raw_text in ['EDGE_ENHANCE_MORE', 'Edge_enhance_more', 'edge_enhance_more', 'Edge_Enhance_More', 'Edge_enhance_More']:
+            filters.append(ImageFilter.EDGE_ENHANCE_MORE)
+        elif raw_text in ['EMBOSS', 'Emboss', 'emboss']:
+            filters.append(ImageFilter.EMBOSS)
+        elif raw_text in ['FIND_EDGES', 'Find_edges', 'find_edges', 'Find_Edges']:
+            filters.append(ImageFilter.FIND_EDGES)
+        elif raw_text in ['SHARPEN', 'Sharpen', 'sharpen']:
+            filters.append(ImageFilter.SHARPEN)
+        elif raw_text in ['SMOOTH', 'Smooth', 'smooth']:
+            filters.append(ImageFilter.SMOOTH)
+        elif raw_text in ['SMOOTH_MORE', 'Smooth_more', 'smooth_more', 'Smooth_More']:
+            filters.append(ImageFilter.SMOOTH_MORE)
+    return filters
+
+def get_resampler(resample_filter):
+    if resample_filter in ['nearest', 'Nearest', 'NEAREST']:            
+        return Image.Resampling.NEAREST 
+    elif resample_filter in ['bicubic', 'Bicubic', 'BICUBIC']:            
+        return Image.Resampling.BICUBIC    
+    elif resample_filter in ['bilinear', 'Bilinear', 'BILINEAR']:            
+        return Image.Resampling.BILINEAR    
+    elif resample_filter in ['box', 'Box', 'BOX']:            
+        return Image.Resampling.BOX    
+    elif resample_filter in ['hamming', 'Hamming', 'HAMMING']:            
+        return Image.Resampling.HAMMING    
+    else:
+        return Image.Resampling.LANCZOS
+
+
+def is_layer_active(frame_dict, config):
+    #Return a boolean if the layer should be visible on screen    
+    fade_in_len = config.getint('fade_in_duration', 20)
+    fade_out_len = config.getint('fade_out_duration', 120)
+    start = config.getint('start_frame', 0)
+    try:
+        end = config.getint('end_frame')
+    except:
+        end = None
+    state, state_counter = int(frame_dict['state']), int(frame_dict['state_counter'])
+    curframe = int(frame_dict['frame_of_input'])
+
+    if state < 1 or curframe <= start:
+        return False
+    if end and curframe >= end + fade_out_len:
+        return False
+    if end is None and state >= 4 and state_counter >= fade_out_len:
+        return False
+    return True
+
+def fade_image_manually(image, frame_dict, config):
+    fade_in_len = max(1,config.getint('fade_in_duration', 20))
+    fade_out_len = max(1,config.getint('fade_out_duration', 120))
+    start = config.getint('start_frame', 0)
+    try:
+        end = config.getint('end_frame')
+    except:
+        end = None
+    state, state_counter = int(frame_dict['state']), int(frame_dict['state_counter'])
+    curframe = int(frame_dict['frame_of_input'])
+
+    if state >= 1 and start <= curframe < fade_in_len + start :
+        #fade in
+        alpha = (curframe - start)/fade_in_len
+        r,g,b,a = image.split()
+        a = a.point(lambda x:x*alpha)
+        image = Image.merge("RGBA", (r,g,b,a))
+    if end is None and state >= 4 and state_counter < fade_out_len:
+        #fade out on stage 4
+        alpha = 1 - state_counter/fade_out_len
+        r,g,b,a = image.split()
+        a = a.point(lambda x:x*alpha)
+        image = Image.merge("RGBA", (r,g,b,a))
+    if end and end < curframe <= fade_out_len + end :
+        #fade out on frame > end 
+        alpha = 1 - (curframe - end)/fade_out_len
+        r,g,b,a = image.split()
+        a = a.point(lambda x:x*alpha)
+        image = Image.merge("RGBA", (r,g,b,a))
+    return image
+
+def fly_in(frame_dict, height):
+    state, state_counter = int(frame_dict['state']), int(frame_dict['state_counter'])
+
+    if state == 1 and 10 < state_counter < 21:
+        DISPLACEMENT_RATIOS = [0.0757, 0.1549, 0.225, 0.4333, 0.382, 0.3402, 0.308, 0.284, 0.269, 0.265]
+        idx = state_counter - 11
+        return round(DISPLACEMENT_RATIOS[idx]*height)
+    if state == 4 and 192 < state_counter < 202:
+        FLY_OUT_RATE = 1/10
+        idx = state_counter - 192
+        return FLY_OUT_RATE * idx
+    return None