def callback(ch, method, properties, body): work_data = jsonpickle.decode(body) id = work_data['id'] split_filename = work_data['split_filename'] log(channel, 'info', 'Received work request for chunk: {}'.format(split_filename)) start_time = time.time() # Get status from DB data = db_data.find_one({'id': id}) if data == None: # If id is not in database, ACK here because we don't want an endless worker loop ch.basic_ack(delivery_tag=method.delivery_tag) raise Exception('No data in database for ID {}'.format(id)) # Create working directories work_path = 'upscale/{}'.format(id) os.makedirs(work_path, exist_ok=True) # Download chunk log(channel, 'debug', 'Downloading chunk: {}'.format(split_filename)) storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) blob = bucket.blob(split_filename) work_file = '{}/{}'.format(work_path, split_filename) blob.download_to_filename(work_file) # Upscale the chunk output_file = '{}_upscaled.avi'.format(split_filename.split('.')[0]) output_file_path = '{}/{}'.format(work_path, output_file) scale_factor = 4 model = dnn_superres.DnnSuperResImpl_create() model.readModel("ESPCN_x4.pb") model.setModel("espcn", scale_factor) log(channel, 'debug', 'Upscaling chunk: {}'.format(output_file)) single_process(work_file, output_file_path, model, scale_factor) # Upload upscaled chunk log(channel, 'debug', 'Uploading chunk: {}'.format(output_file)) blob = bucket.blob(output_file) blob.upload_from_filename(output_file_path) # Clean up working directories shutil.rmtree(work_path) # Update DB status completion_time = time.time() db_data.update_one({ 'id': id, 'splits.name': split_filename }, { '$set': { 'splits.$.upscale_name': output_file, 'splits.$.time_start': start_time, 'splits.$.time_end': completion_time, 'splits.$.status': 'COMPLETE' } }) ch.basic_ack(delivery_tag=method.delivery_tag)
def sr_operate(img_path): # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image img_array = np.fromfile(img_path, np.uint8) #image = cv2.imread(img_path) image = cv2.imdecode(img_array, cv2.IMREAD_COLOR) # Read the desired model path = "FSRCNN_x4.pb" path = os.path.abspath(path) sr.readModel(path) # Set CUDA backend and target to enable GPU inference #sr.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA) #sr.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("fsrcnn", 4) # Upscale the image result = sr.upsample(image) # Save the image save_path = "d:\\carz_operated\\sr_img" if not os.path.exists(save_path): os.mkdir(save_path) cv2.imwrite(save_path + "\\upscaled.png", result) return save_path + "\\upscaled.png"
def __init__( self: Detector, config: Config ) -> None: self.config = config # self.model = Model(config=config) self.model = None dataset_name = config.image_dir.split(os.sep)[-1] if self.config.framework == 'tflite': self.result_dir = 'results/%s/%s_%s_%s' % ( dataset_name, config.model, config.framework, config.quantize ) else: self.result_dir = 'results/%s/%s_%s' % ( dataset_name, config.model, config.framework ) os.makedirs(self.result_dir, exist_ok=True) self.sr = None if config.use_superres: self.sr = dnn_superres.DnnSuperResImpl_create() self.sr.readModel('superres/ESPCN_x4.pb') self.sr.setModel('espcn', 4) self.wf = open(os.path.join( self.result_dir, 'predictions.jsonl' ), 'wt') return
def _load_superresolution_models(): data_dir = os.path.dirname(__file__) + '/superresolution/' for scale in (2, 4, 8): Rescale._sr_dict[scale] = dnn_superres.DnnSuperResImpl_create() Rescale._sr_dict[scale].readModel(data_dir + 'LapSRN_x' + str(scale) + '.pb') Rescale._sr_dict[scale].setModel('lapsrn', scale)
def superscale(self, img: Image.Image) -> Image.Image: """Performs upsampling using superresolution neural networks. At the moment, OpenCV offers four models, three of which you can choose here: LAPSRN, ESPCN, FSRCNN. All of which can upsample by the factor of 4. Other versions can be downloaded too, the EDSR model is too large and too slow. Quellen: https://towardsdatascience.com/deep-learning-based-super-resolution-with-opencv-4fd736678066 https://docs.opencv.org/master/d5/d29/tutorial_dnn_superres_upscale_image_single.html Args: img (Image.Image): Image to be upscaled. Returns: Image.Image: The upsampled image. """ superscaler = dnn_superres.DnnSuperResImpl_create() model_path = os.path.join( 'data', 'models', f'{self.model_name.upper()}_x{self.scale_factor}.pb') superscaler.readModel(model_path) superscaler.setModel(self.model_name, self.scale_factor) img = img.convert('RGB') img = np.array(img) img = superscaler.upsample(img) img = Image.fromarray(img.astype('uint8'), 'RGB') return img
def __init__(self, parent=None): super().__init__() self.play = True self.sr = dnn_superres.DnnSuperResImpl_create() self.path = "models/ESPCN_x4.pb" self.sr.readModel(self.path) self.sr.setModel("espcn", 4)
def upScaleEDSR(image): # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() path = "saved_models/EDSR_x3.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("edsr", 3) result = sr.upsample(image) return result
def main(): img_path = "./image/image.png" # 可选择算法,bilinear, bicubic, edsr, espcn, fsrcnn or lapsrn algorithm = "bilinear" # 放大比例,可输入值2,3,4 scale = 4 # 模型路径 path = "./model/LapSRN_x4.pb" # 载入图像 img = cv2.imread(img_path) # 如果输入的图像为空 if img is None: print("Couldn't load image: " + str(img_path)) return original_img = img.copy() # 创建模型 sr = dnn_superres.DnnSuperResImpl_create() if algorithm == "bilinear": img_new = cv2.resize(img, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR) elif algorithm == "bicubic": img_new = cv2.resize(img, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC) elif algorithm == "edsr" or algorithm == "espcn" or algorithm == "fsrcnn" or algorithm == "lapsrn": # 读取模型 sr.readModel(path) # 设定算法和放大比例 sr.setModel(algorithm, scale) # 放大图像 img_new = sr.upsample(img) else: print("Algorithm not recognized") # 如果失败 if img_new is None: print("Upsampling failed") print("Upsampling succeeded. \n") # Display # 展示图片 cv2.namedWindow("Initial Image", cv2.WINDOW_AUTOSIZE) # 初始化图片 cv2.imshow("Initial Image", img_new) cv2.imwrite("./saved.jpg", img_new) cv2.waitKey(0)
def main(): input_path = "./video/chaplin.mp4" output_path = "./video/out_chaplin.mp4" # 选择模型 edsr, espcn, fsrcnn or lapsrn algorithm = "lapsrn" # 放大比例,2,3,4,8,根据模型结构选择 scale = 2 # 模型路径 path = "./model/LapSRN_x2.pb" # 打开视频 input_video = cv2.VideoCapture(input_path) # 输入图像编码尺寸 ex = int(input_video.get(cv2.CAP_PROP_FOURCC)) # 获得输出视频图像尺寸 # 如果视频没有打开 if input_video is None: print("Could not open the video.") return S = (int(input_video.get(cv2.CAP_PROP_FRAME_WIDTH)) * scale, int(input_video.get(cv2.CAP_PROP_FRAME_HEIGHT)) * scale) output_video = cv2.VideoWriter(output_path, ex, input_video.get(cv2.CAP_PROP_FPS), S, True) # 读取超分放大模型 sr = dnn_superres.DnnSuperResImpl_create() sr.readModel(path) sr.setModel(algorithm, scale) while True: ret, frame = input_video.read() # 捕获一帧图像 if not ret: print("read video error") return # 上采样图像 output_frame = sr.upsample(frame) output_video.write(output_frame) cv2.namedWindow("Upsampled video", cv2.WINDOW_AUTOSIZE) cv2.imshow("Upsampled video", output_frame) cv2.namedWindow("Original video", cv2.WINDOW_AUTOSIZE) cv2.imshow("Original video", frame) c = cv2.waitKey(1) # esc退出 if 27 == c: break input_video.release() output_video.release()
def superresolution(img): # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read the desired model path = "/content/drive/My Drive/Images/EDSR_x4.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("edsr", 3) # Upscale the image img = sr.upsample(img) return img
def upscaler(self): try: self.vid = cv2.VideoCapture(self.filename) self.text_image_seq.configure(text='Upscaling Video', anchor='w') self.seq_progress.place(relx=0.099, rely=0.505, relwidth=0.791 , relheight=0.0, height=22) self.seq_progress.configure(length="400") self.pvalue = 100 / self.T_frames self.text_image_seq_2.configure(text='''''') root.update_idletasks() imgs = [] sr = dnn_superres.DnnSuperResImpl_create() path = "datamodel\\ESPCN_x2.pb" sr.readModel(path) sr.setModel("espcn", 2) for i in range(1, self.T_frames + 1): ret, frame = self.vid.read() upimg = sr.upsample(frame) height, width, layers = upimg.shape size = (width, height) imgs.append(upimg) self.seq_progress['value'] += self.pvalue root.update_idletasks() root.update() self.text_image_seq_2.configure(text='''----Upscalling Done----''') self.seq_progress['value'] = 0 print("Exporting Video....") self.text_image_seq.configure(text='Exporting Video....', anchor='w') root.update_idletasks() output = cv2.VideoWriter(str(self.o_direct) + '\\output.avi', cv2.VideoWriter_fourcc(*'DIVX'), 24, size) for i in range(self.T_frames): # print(i) output.write(imgs[i]) self.seq_progress['value'] += self.pvalue root.update_idletasks() root.update() self.text_image_seq_2.configure(text='''----Video Exported----''') print("Video Exported.") except: self.text_image_seq_2.configure(text='''----Provide a valid Video File----''') self.text_image_seq.configure(text='', anchor='w') root.update_idletasks()
def supper_res(path): sr = dnn_superres.DnnSuperResImpl_create() image = cv2.imread(path) modelPath = "ESPCN_x4.pb" sr.readModel(modelPath) sr.setModel("espcn", 4) imls=np.array_split(image,4) for i in range(len(imls)): imls[i]=sr.upsample(imls[i]) print(i) result=np.concatenate(imls) #result = cv2.merge((sr.upsample(b),sr.upsample(g),sr.upsample(r))) cv2.imwrite(path[:-4]+"_Large.jpg", result) return path[:-4]+"_Large.jpg"
def super_resolution(image: np.ndarray) -> np.ndarray: # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read the desired model path = "/home/appuser/data/weight_for_super_resolution/EDSR_x4.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("edsr", 4) # Upscale the image upsampled = sr.upsample(image) return upsampled
def upscale(image): sr = dnn_superres.DnnSuperResImpl_create() edsr_model_path = Path("/watercolor-processing/models/EDSR_x3.pb") fsr_model_path = Path("/watercolor-processing/models/FSRCNN_x3.pb") #print("model path: ", model_path, flush=True) sr.readModel(str(fsr_model_path)) #"edsr" or "fsrcnn" sr.setModel("fsrcnn", 3) print(f"started upscaling image with shape: {image.shape}") result = sr.upsample(image) print(f"finished upscaling image: {result.shape}") return result
def upscale(path, guildId): start_time = time.time() sr = dnn_superres.DnnSuperResImpl_create() image_path = cv2.imread(path) # change path to change model model_path = os.path.join(os.getcwd(), "models/EDSR_x3.pb") sr.readModel(model_path) # first param is the name of the model # second param is the scale of the model, scale of the model is in the name of the file of the model sr.setModel("edsr", 3) result = sr.upsample(image_path) cv2.imwrite(path, result) print("--- %s seconds ---" % (time.time() - start_time))
def enhance_resolution(self, output_path): ''' Enhance the resolution of the image using Super Resolution technique ''' MODEL_PATH = "./assets/FSRCNN_x4.pb" img = cv2.imread(self.__file) # Apply DNN Super Resolution technique using pre trained model (in our case FSRCNN model) sr = dnn_superres.DnnSuperResImpl_create() sr.readModel(MODEL_PATH) sr.setModel("fsrcnn", 4) final_img = sr.upsample(img) final_img = cv2.fastNlMeansDenoisingColored(final_img, None, 10, 10, 7, 15) # Remove Noise self.reduce_img_size(final_img, output_path, "enhanced_resolution")
def test_super_resolution(self): # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image image = cv2.imread(_input_path) # Read the desired model path = "/home/appuser/data/weight_for_super_resolution/EDSR_x4.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("edsr", 4) # Upscale the image result = sr.upsample(image) # Save the image cv2.imwrite(_output_path, result)
def scaleUp(source: str, dest: str): global scaleFactor, filename, dirname # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image image = cv2.imread(source) # Read the desired model path = f'{dirname}/Model/LapSRN_x8.pb' sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("lapsrn", scaleFactor) # Upscale the image result = sr.upsample(image) # Save the image cv2.imwrite(dest, result)
def sr_work(): try: # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image image = cv2.imread('../../image/input.png') # Read the desired model path = "EDSR_x3.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("edsr", 3) # Upscale the image result = sr.upsample(image) # Save the image cv2.imwrite("../../image/upscaled.png", result) except: print("error")
def _DNN_SR_processor(self): # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image self.imageLoader.image_directory = self.image self.imageLoader.load_image() image = self.imageLoader.image_array # Read the desired model sr.readModel( '{cur_dir}/../../../resource/DeepLearningModels/{method_folder}/{method_name}_x{scale_factor}.pb' .format(method_folder=self._method, method_name=self._method, scale_factor=self._scale_factor, cur_dir=self.current_dir)) # Set the desired model and scale to get correct pre- and post-processing sr.setModel(self._method.lower(), self._scale_factor) # Upscale the image result = sr.upsample(image) return result
def resolute(): generator = torch.load("WEIGHTS/w2.pth", map_location="cpu") generator.eval() device = torch.device('cpu') generator.to(device) y = generator(torch.randn(batch_size, latent_size, 1, 1)) gen_imgs = denorm(y.detach()) to_pil_image = transforms.ToPILImage() result1 = to_pil_image(gen_imgs[0]) result2 = to_pil_image(gen_imgs[1]) result3 = to_pil_image(gen_imgs[2]) newsize = (70, 70) im1 = result1.resize(newsize) im2 = result2.resize(newsize) im3 = result3.resize(newsize) im1 = im1.save("SUPERSAMPLES/new.jpg", quality=100) im2 = im2.save("SUPERSAMPLES/new1.jpg", quality=100) im3 = im3.save("SUPERSAMPLES/new2.jpg", quality=100) sr = dnn_superres.DnnSuperResImpl_create() image = cv2.imread('./SUPERSAMPLES/new.jpg') image2 = cv2.imread('./SUPERSAMPLES/new1.jpg') image3 = cv2.imread('./SUPERSAMPLES/new2.jpg') path = "LapSRN_x8.pb" sr.readModel(path) sr.setModel("lapsrn", 8) result = sr.upsample(image) result1 = sr.upsample(image2) result2 = sr.upsample(image3) cv2.imwrite("./SUPERSAMPLES/supernew.png", result) cv2.imwrite("./SUPERSAMPLES/supernew1.png", result1)
def upscale(image_path, model_name, model_path, scale, output_path='./upscaled.png'): if model_name not in models: print('{0} not a valid model'.format(model_name)) return sr = dnn_superres.DnnSuperResImpl_create() image = cv2.imread(image_path) sr.readModel(model_path) # code for CUDA acceleration # to use, opencv must be built with cuda support # sr.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA) # sr.setPreferableBackend(cv2.dnn.DNN_TARGET_CUDA) # set the desired model and scale sr.setModel(model_name, scale) upscaled_image = sr.upsample(image) cv2.imwrite(output_path, upscaled_image)
import cv2 from cv2 import dnn_superres # Create an SR object - only function that differs from c++ code sr = dnn_superres.DnnSuperResImpl_create() # Read image image = cv2.imread('./file_250.jpg') # Read the desired model path = "ESPCN_x3.pb" sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel("espcn", 3) # Upscale the image result = sr.upsample(image) # Save the image cv2.imwrite("./upscaled.jpg", result)
def get_superscaler(): super_res = dnn_superres.DnnSuperResImpl_create() path = get_model_path() super_res.readModel(path) super_res.setModel(superres_settings["model"], superres_settings["scale"]) return super_res
def timeslide(self): # colorization if (self.colorize_int.get() == 1): # set status self.label_status.config(text="Colorizing. Please stand by...") self.update() # determine colorizer model if (self.model_vars.get() == "Artistic"): colorizer = get_image_colorizer(artistic=True) elif (self.model_vars.get() == "Stable"): colorizer = get_image_colorizer(artistic=False) # get render factor render_factor = self.scale_rf.get() if self.load_method in "open_file": self.result_path = colorizer.plot_transformed_image( path=self.file_path, render_factor=render_factor, compare=False) elif self.load_method in "load_url": print(self.str_url.get("1.0", tk.END)) self.result_path = colorizer.plot_transformed_image_from_url( url=self.str_url.get("1.0", tk.END), path='//tmp/tmp.png', render_factor=render_factor, compare=False) self.img_base = Image.open(self.result_path) # display to canvas self.show_image() # do enhancement if (self.enhance_int.get() == 1): # set status self.label_status.config(text="Enhancing. Please stand by...") self.update() # determine which file we're reading if (self.colorize_int.get() == 1): filepath = self.result_path else: filepath = self.file_path # Create an SR object sr = dnn_superres.DnnSuperResImpl_create() # Read image image = cv2.imread(str(filepath)) # Read the desired model, enhance factor model = self.weights_vars.get() enhance_factor = int(self.scale_ef.get()) path = "models/%s_x%i.pb" % (model, enhance_factor) sr.readModel(path) # Set the desired model and scale to get correct pre- and post-processing sr.setModel(model.lower(), enhance_factor) # Upscale the image result = sr.upsample(image) # Save the image self.result_path = './tmp_enhance.jpg' cv2.imwrite(self.result_path, result) # display to canvas self.img_base = Image.open(self.result_path) self.show_image() # set status to complete self.label_status.config(text="TimeSlide complete!") # enable save button self.btn_save_photo['state'] = 'normal'
def main(): # 图片路径 img_path = "./image/image.png" # 算法名称 edsr, espcn, fsrcnn or lapsrn algorithm = "lapsrn" # 模型路径,根据算法确定 model = "./model/LapSRN_x2.pb" # 放大系数 scale = 2 # 时间系数 perf = [] img = cv2.imread(img_path) if img is None: print("Couldn't load image: " + str(img_path)) # Crop the image so the images will be aligned # 裁剪图像,使图像对齐 width = img.shape[0] - (img.shape[0] % scale) height = img.shape[1] - (img.shape[1] % scale) cropped = img[0:width, 0:height] # Downscale the image for benchmarking # 缩小图像,以实现基准质量测试 img_downscaled = cv2.resize(cropped, None, fx=1.0 / scale, fy=1.0 / scale) # Make dnn super resolution instance # 超分模型初始化 sr = dnn_superres.DnnSuperResImpl_create() # Read and set the dnn model # 读取和设定模型 sr.readModel(model) sr.setModel(algorithm, scale) timer = cv2.TickMeter() timer.start() # 放大图像 img_new = sr.upsample(img_downscaled) timer.stop() # 运行时间s elapsed = timer.getTimeSec() / timer.getCounter() perf.append(elapsed) print(sr.getAlgorithm() + " : " + str(elapsed)) # INTER_CUBIC - 三次样条插值放大图像 timer.start() bicubic = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC) timer.stop() # 运行时间s elapsed = timer.getTimeSec() / timer.getCounter() perf.append(elapsed) print("Bicubic" + " : " + str(elapsed)) # INTER_NEAREST - 最近邻插值 timer.start() nearest = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST) timer.stop() # 运行时间s elapsed = timer.getTimeSec() / timer.getCounter() perf.append(elapsed) print("Nearest" + " : " + str(elapsed)) # Lanczos插值放大图像 timer.start() lanczos = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_LANCZOS4) timer.stop() # 运行时间s elapsed = timer.getTimeSec() / timer.getCounter() perf.append(elapsed) print("Lanczos" + " : " + str(elapsed)) imgs = [img_new, bicubic, nearest, lanczos] titles = [sr.getAlgorithm(), "Bicubic", "Nearest neighbor", "Lanczos"] showBenchmark(imgs, titles, perf)
def main(): # 图片路径 img_path = "./image/butterfly.png" # 算法名称 edsr, espcn, fsrcnn or lapsrn algorithm = "lapsrn" # 模型路径,根据算法确定 model = "./model/LapSRN_x2.pb" # 放大系数 scale = 2 psnrValues = [] ssimValues = [] img = cv2.imread(img_path) if img is None: print("Couldn't load image: " + str(img_path)) # Crop the image so the images will be aligned # 裁剪图像,使图像对齐 width = img.shape[0] - (img.shape[0] % scale) height = img.shape[1] - (img.shape[1] % scale) cropped = img[0:width, 0:height] # Downscale the image for benchmarking # 缩小图像,以实现基准质量测试 img_downscaled = cv2.resize(cropped, None, fx=1.0 / scale, fy=1.0 / scale) # Make dnn super resolution instance # 超分模型初始化 sr = dnn_superres.DnnSuperResImpl_create() # Read and set the dnn model # 读取和设定模型 sr.readModel(model) sr.setModel(algorithm, scale) # 放大图像 img_new = sr.upsample(img_downscaled) # DL MODEL # 获得模型质量评估值 psnr, ssim = getQualityValues(cropped, img_new) psnrValues.append(psnr) ssimValues.append(ssim) print(sr.getAlgorithm() + "\n") print("PSNR: " + str(psnr) + " SSIM: " + str(ssim) + "\n") print("-" * 50) # INTER_CUBIC - 三次样条插值放大图像 bicubic = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC) psnr, ssim = getQualityValues(cropped, bicubic) psnrValues.append(psnr) ssimValues.append(ssim) print("Bicubic \n") print("PSNR: " + str(psnr) + " SSIM: " + str(ssim) + "\n") print("-" * 50) # INTER_NEAREST - 最近邻插值 nearest = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST) psnr, ssim = getQualityValues(cropped, nearest) psnrValues.append(psnr) ssimValues.append(ssim) print("Nearest neighbor \n") print("PSNR: " + str(psnr) + " SSIM: " + str(ssim) + "\n") print("-" * 50) # Lanczos插值放大图像 lanczos = cv2.resize(img_downscaled, None, fx=scale, fy=scale, interpolation=cv2.INTER_LANCZOS4); psnr, ssim = getQualityValues(cropped, lanczos) psnrValues.append(psnr) ssimValues.append(ssim) print("Lanczos \n") print("PSNR: " + str(psnr) + " SSIM: " + str(ssim) + "\n") print("-" * 50) imgs = [img_new, bicubic, nearest, lanczos] titles = [sr.getAlgorithm(), "Bicubic", "Nearest neighbor", "Lanczos"] showBenchmark(imgs, titles, psnrValues, ssimValues)