def verify_upscaling_works(self) -> None:
"""
Verify the upscaler works by upscaling a very small frame, and throws a descriptive error if it doesn't.
"""
test_file = self.context.service_request.workspace + "test_frame.jpg"
test_file_upscaled = self.context.service_request.workspace + "test_frame_upscaled.jpg"
test_frame = Frame()
test_frame.create_new(2, 2)
test_frame.save_image(test_file)
self.log.info(
"Attempting to upscale file %s into %s to ensure waifu2x is working..."
% (test_file, test_file_upscaled))
self.upscale_file(test_file, test_file_upscaled)
if not file_exists(test_file_upscaled):
self.log.error(
"Your computer could not upscale a test image, which is required for dandere2x to work."
)
self.log.error(
"This may be a hardware issue or a software issue - verify your computer is capable of upscaling "
"images using the selected upscaler.")
raise Exception("Your computer could not upscale the test file.")
self.log.info(
"Upscaling *seems* successful. Deleting files and continuing forward. "
)
os.remove(test_file)
os.remove(test_file_upscaled)
def debug_image(block_size, frame_base, list_predictive, list_residuals, output_location):
"""
Note:
I haven't made an effort to maintain this method, as it's only for debugging.
This section can best be explained through pictures. A visual way of expressing what 'debug'
is doing is this section in the wiki.
https://github.com/aka-katto/dandere2x/wiki/How-Dandere2x-Works#part-1-identifying-what-needs-to-be-drawn
In other words, this method shows where residuals are, and is useful for finding good settings to use for a video.
Inputs:
- frame(x)
- Residual vectors mapping frame(x)_residual -> frame(x)
Output:
- frame(x) minus frame(x)_residuals = debug_image
"""
logger = logging.getLogger(__name__)
difference_vectors = []
predictive_vectors = []
out_image = Frame()
out_image.create_new(frame_base.width, frame_base.height)
out_image.copy_image(frame_base)
black_image = Frame()
black_image.create_new(frame_base.width, frame_base.height)
if not list_predictive and not list_residuals:
out_image.save_image(output_location)
return
if list_predictive and not list_residuals:
out_image.copy_image(frame_base)
out_image.save_image(output_location)
return
# load list into vector displacements
for x in range(int(len(list_residuals) / 4)):
difference_vectors.append(DisplacementVector(int(list_residuals[x * 4]),
int(list_residuals[x * 4 + 1]),
int(list_residuals[x * 4 + 2]),
int(list_residuals[x * 4 + 3])))
for x in range(int(len(list_predictive) / 4)):
if (int(list_predictive[x * 4 + 0]) != int(list_predictive[x * 4 + 1])) and \
(int(list_predictive[x * 4 + 2]) != int(list_predictive[x * 4 + 3])):
predictive_vectors.append(DisplacementVector(int(list_predictive[x * 4 + 0]),
int(list_predictive[x * 4 + 1]),
int(list_predictive[x * 4 + 2]),
int(list_predictive[x * 4 + 3])))
# copy over predictive vectors into new image
for vector in difference_vectors:
out_image.copy_block(black_image, block_size,
vector.x_1, vector.y_1,
vector.x_1, vector.y_1)
out_image.save_image_quality(output_location, 25)
def run(self):
self.log.info("Run called.")
for x in range(1, self.con.frame_count):
# Files needed to create a residual image
f1 = Frame()
f1.load_from_string_controller(self.con.input_frames_dir + "frame" + str(x + 1) + ".png",
self.controller)
# Load the neccecary lists to compute this iteration of residual making
residual_data = get_list_from_file_and_wait(self.con.residual_data_dir + "residual_" + str(x) + ".txt")
prediction_data = get_list_from_file_and_wait(self.con.pframe_data_dir + "pframe_" + str(x) + ".txt")
# Create the output files..
debug_output_file = self.con.debug_dir + "debug" + str(x + 1) + ".png"
output_file = self.con.residual_images_dir + "output_" + get_lexicon_value(6, x) + ".png"
# Save to a temp folder so waifu2x-vulkan doesn't try reading it, then move it
out_image = self.make_residual_image(self.con, 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.con.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(out_location=output_file, temp_location=self.con.temp_image)
# With this change the wrappers must be modified to not try deleting the non existing residual file
if self.con.debug is True:
self.debug_image(block_size=self.con.service_request.block_size, frame_base=f1,
list_predictive=prediction_data, list_residuals=residual_data,
output_location=debug_output_file)