def run(self):
self.log.info("Run called.")
for x in range(self.start_frame, self.frame_count):
# Stop if thread is killed
if not self.context.controller.is_alive():
break
# Files needed to create a residual image
f1 = Frame()
f1.load_from_string_controller(
self.input_frames_dir + "frame" + str(x + 1) +
self.extension_type, self.context.controller)
# Load the neccecary lists to compute this iteration of residual making
residual_data = get_list_from_file_and_wait(
self.residual_data_dir + "residual_" + str(x) + ".txt",
self.context.controller)
prediction_data = get_list_from_file_and_wait(
self.pframe_data_dir + "pframe_" + str(x) + ".txt",
self.context.controller)
# stop if thread is killed
if not self.context.controller.is_alive():
break
# Create the output files..
debug_output_file = self.debug_dir + "debug" + str(
x + 1) + self.extension_type
output_file = self.residual_images_dir + "output_" + get_lexicon_value(
6, x) + ".jpg"
# Save to a temp folder so waifu2x-vulkan doesn't try reading it, then move it
out_image = self.make_residual_image(self.context, f1,
residual_data,
prediction_data)
if out_image.get_res() == (1, 1):
"""
If out_image is (1,1) in size, then frame_x and frame_x+1 are identical.
We still need to save an outimage for sake of having N output images for N input images, so we
save these meaningless files anyways.
However, these 1x1 can slow whatever waifu2x implementation down, so we 'cheat' d2x
but 'fake' upscaling them, so that they don't need to be processed by waifu2x.
"""
# Location of the 'fake' upscaled image.
out_image = Frame()
out_image.create_new(2, 2)
output_file = self.residual_upscaled_dir + "output_" + get_lexicon_value(
6, x) + ".png"
out_image.save_image(output_file)
else:
# This image has things to upscale, continue normally
out_image.save_image_temp(output_file, self.temp_image)
# With this change the wrappers must be modified to not try deleting the non existing residual file
if self.context.debug == 1:
self.debug_image(self.block_size, f1, prediction_data,
residual_data, debug_output_file)
def residual_loop(context):
"""
Call the 'make_residual_image' method for every image that needs to be made into a residual.
Method Tasks:
- Load and wait for the files needed to create a residual image.
- Call 'make_residual_image' once the needed files exist
"""
# load variables from context
workspace = context.workspace
residual_upscaled_dir = context.residual_upscaled_dir
residual_images_dir = context.residual_images_dir
residual_data_dir = context.residual_data_dir
pframe_data_dir = context.pframe_data_dir
input_frames_dir = context.input_frames_dir
frame_count = context.frame_count
block_size = context.block_size
extension_type = context.extension_type
debug_dir = context.debug_dir
debug = context.debug
temp_image = context.temp_image_folder + "tempimage.jpg"
logger = logging.getLogger(__name__)
logger.info((workspace, 1, frame_count, block_size))
# for every frame in the video, create a residual_frame given the text files.
for x in range(1, frame_count):
f1 = Frame()
f1.load_from_string_wait(input_frames_dir + "frame" + str(x + 1) +
extension_type)
# Load the neccecary lists to compute this iteration of residual making
residual_data = get_list_from_file(residual_data_dir + "residual_" +
str(x) + ".txt")
prediction_data = get_list_from_file(pframe_data_dir + "pframe_" +
str(x) + ".txt")
# Create the output files..
debug_output_file = debug_dir + "debug" + str(x + 1) + extension_type
output_file = residual_images_dir + "output_" + get_lexicon_value(
6, x) + ".jpg"
# Save to a temp folder so waifu2x-vulkan doesn't try reading it, then move it
out_image = make_residual_image(context, f1, residual_data,
prediction_data)
if out_image.get_res() == (1, 1):
"""
If out_image is (1,1) in size, then frame_x and frame_x+1 are identical.
We still need to save an outimage for sake of having N output images for N input images, so we
save these meaningless files anyways.
However, these 1x1 can slow whatever waifu2x implementation down, so we 'cheat' d2x
but 'fake' upscaling them, so that they don't need to be processed by waifu2x.
"""
# Location of the 'fake' upscaled image.
out_image = Frame()
out_image.create_new(2, 2)
output_file = residual_upscaled_dir + "output_" + get_lexicon_value(
6, x) + ".png"
out_image.save_image(output_file)
else:
# This image has things to upscale, continue normally
out_image.save_image_temp(output_file, temp_image)
# With this change the wrappers must be modified to not try deleting the non existing residual file
if debug == 1:
debug_image(block_size, f1, prediction_data, residual_data,
debug_output_file)
