def part_four(hdr1, hdr2): cv2.imwrite('./results/part_four/hdr1_original.png', hdr1) cv2.imwrite('./results/part_four/hdr2_original.png', hdr2) tonemap1 = cv2.createTonemapReinhard(3.5, -2.0, 0.25, 0.75) tonemap2 = cv2.createTonemapReinhard(3.5, 0.0, 0.25, 0.0) tonemapHDR1 = tonemap1.process(hdr1) tonemapHDR2 = tonemap2.process(hdr2) cv2.imwrite('./results/part_four/hdr1_tonemap.png', tonemapHDR1 * 255) cv2.imwrite('./results/part_four/hdr2_tonemap.png', tonemapHDR2 * 255)
def tMO(file,name): #tonemapping the file try: if (name == 'reinhard'): print('Reinhard') intensity=-1.0 light_adapt=0.8 color_adapt=0.0 gamma=2.0 tmo = cv2.createTonemapReinhard(gamma=gamma, intensity=intensity, light_adapt=light_adapt, color_adapt=color_adapt) #([, gamma[, intensity[, light_adapt[, color_adapt]]]]) https://www.kite.com/python/docs/cv2.createTonemapReinhard# if (name == 'mantiuk'): print('Mantiuk') saturation=1.0 scale=0.75 gamma=2.0 tmo = cv2.createTonemapMantiuk(saturation=saturation, scale=scale, gamma=gamma) if (name == 'drago'): print('Drago') saturation=1.0 bias=0.85 gamma=2.0 tmo = cv2.createTonemapDrago(saturation=saturation, bias=bias, gamma=gamma) if (name == 'linear'): print('Linear') gamma=2.0 tmo = cv2.createTonemap(gamma=gamma) except: print('ToneMapping Error') ldr = tmo.process(file) return ldr
def reinhard(x, intensity=0.0, light_adapt=0.9, color_adapt=0.1, gamma=2.2): return cv2.createTonemapReinhard( gamma=gamma, intensity=intensity, light_adapt=light_adapt, color_adapt=color_adapt, ).process(x)
def tonemap(hdr): def tmCallback(val): pass #create user interface w/ tone mapping controls cv2.namedWindow("Tone Map", cv2.WINDOW_NORMAL) cv2.resizeWindow("Tone Map", 750, 750) cv2.imshow("Tone Map", hdr) cv2.createTrackbar("Gamma ", "Tone Map", 0, 4, tmCallback) cv2.createTrackbar("Vibrance", "Tone Map", 0, 4, tmCallback) finished = False while not finished: key = cv2.waitKey(0) if key == ord('a'): finished = True #capture trackbar values gamma = cv2.getTrackbarPos("Gamma ", "Tone Map") comp = cv2.getTrackbarPos("Vibrance", "Tone Map") cv2.destroyAllWindows() print("Tone Mapping...") # Tonemap using Reinhard's method to obtain 24-bit color image tonemap = cv2.createTonemapReinhard(gamma / 4.0, 0, comp / 4.0, 0) ldr = tonemap.process(hdr) completeName = os.path.join(savePath, "Tonemapped.jpg") cv2.imwrite(completeName, ldr * 255) return ldr
def main(): img = cv2.imread(IMG_LIST[0]) shape = img.shape width = shape[0] height = shape[1] imgListB, imgListG, imgListR = loadImgs() z_b, z_g, z_r = genCompPixel(imgListB, imgListG, imgListR) B = [math.log(e) for e in exposure_times] w = [z if z <= 127 else 255 - z for z in range(256)] # calculate Camera Response Curve L = 50 crcB = CalCRC(z_b, B, L, w) crcG = CalCRC(z_g, B, L, w) crcR = CalCRC(z_r, B, L, w) blueCurve = np.exp(genRadMap(imgListB, crcB, B, w)) greenCurve = np.exp(genRadMap(imgListG, crcG, B, w)) redCurve = np.exp(genRadMap(imgListR, crcR, B, w)) drawCRC(crcB, crcG, crcR) hdr = np.zeros(shape, 'float32') hdr[..., 0] = np.reshape(blueCurve, (width, height)) hdr[..., 1] = np.reshape(greenCurve, (width, height)) hdr[..., 2] = np.reshape(redCurve, (width, height)) cv2.imwrite('out.hdr', hdr) normalize = lambda zi: (zi - zi.min() / zi.max() - zi.min()) ldr = normalize(np.log(hdr)) cv2.imwrite('hdr_image.jpg', (ldr/ldr.max())*255) tonemapReinhard = cv2.createTonemapReinhard(1.5, 3, 0.5, 0.5) ldrReinhard = tonemapReinhard.process(hdr) cv2.imwrite("ldr-Reinhard.jpg", ldrReinhard * 255)
def process_photos(folders): psave = folders["psave"] ptmp = folders["ptmp"] pgal = folders["pgal"] foldername = folders["foldername"] save_folder = psave + "/" + foldername makedirs(save_folder) onlyfiles = [f for f in listdir(ptmp) if isfile(join(ptmp, f))] images = [] times = np.array([], dtype=np.float32) logging.info("Loading images for HDR") for filename in onlyfiles: filesrc = ptmp + "/" + filename filedest = save_folder + "/" + filename shutil.move(filesrc, filedest) file_data = open(filedest, 'rb') tags = exifread.process_file(file_data) exposure = float(tags['EXIF ExposureTime'].values[0]) im = cv2.imread(filedest) images.append(im) times = np.append(times, np.float32(exposure)) logging.info("Align input images") align_MTB = cv2.createAlignMTB() align_MTB.process(images, images) logging.info('Obtain Camera Response Function (CRF)') calibrate_debevec = cv2.createCalibrateDebevec() response_debevec = calibrate_debevec.process(images, times) logging.info('Merge images into an HDR linear image') merge_debevec = cv2.createMergeDebevec() hdr_debevec = merge_debevec.process(images, times, response_debevec) logging.info('Save HDR image') save_file = pgal + "/" + foldername cv2.imwrite(save_file + ".hdr", hdr_debevec) logging.info("Tonemaping using Drago's method ... ") tonemap_drago = cv2.createTonemapDrago(1.0, 0.7) ldr_drago = tonemap_drago.process(hdr_debevec) ldr_drago = 3 * ldr_drago cv2.imwrite(save_file + "_drago.jpg", ldr_drago * 255) logging.info("Tonemaping using Reinhard's method ... ") tonemap_reinhard = cv2.createTonemapReinhard(1.5, 0,0,0) ldr_reinhard = tonemap_reinhard.process(hdr_debevec) cv2.imwrite(save_file + "_reinhard.jpg", ldr_reinhard * 255) logging.info("Tonemaping using Mantiuk's method ... ") tonemap_mantiuk = cv2.createTonemapMantiuk(2.2,0.85, 1.2) ldr_mantiuk = tonemap_mantiuk.process(hdr_debevec) ldr_mantiuk = 3 * ldr_mantiuk cv2.imwrite(save_file + "_mantiuk.jpg", ldr_mantiuk * 255)
def __init__(self, ip_pi): QThread.__init__(self) self.threadID = 1 self.name = "ImgThread" self.window = None self.saveOn = False self.mergeMertens = cv2.createMergeMertens(1., 1., 1.) self.mergeDebevec = cv2.createMergeDebevec() self.toneMap = cv2.createTonemapReinhard() # self.claheProc = cv2.createCLAHE(clipLimit=1, tileGridSize=(8,8)) # self.simpleWB = cv2.xphoto.createSimpleWB() # self.simpleWB = cv2.xphoto.createGrayworldWB() # self.wb= False # self.equalize = False # self.clahe = False # self.clipLimit = 1. self.reduceFactor = 1 self.ip_pi = ip_pi self.hflip = False self.vflip = False self.table = None self.doCalibrate = False try: npz = np.load("calibrate.npz") self.table = npz['table'] except Exception as e: pass
def tonemapping(hdr, tmo_func='reinhard', gamma=2.2, fstop=0): ## tone mapping hdr if tmo_func == 'reinhard': tmo = cv2.createTonemapReinhard(gamma=gamma) elif tmo_func == 'durand': tmo = cv2.createTonemapDurand(gamma=gamma) elif tmo_func == 'drago': tmo = cv2.createTonemapDrago(gamma=gamma) elif tmo_func == 'mantiuk': tmo = cv2.createTonemapMantiuk(gamma=gamma) elif tmo_func == 'linear': output = hdr - hdr.min() output = output / output.max() # return output return tonemapping(output, tmo_func='gamma') elif tmo_func == 'gamma': inv_gamma = 1.0 / gamma exposure = np.power(2., fstop) output = clamp_img(np.power(exposure * hdr, inv_gamma), 0, 1) return output else: raise NotImplementedError # elif tmo_func =='cut_high': # output = hdr - hdr.min() # output = output/output.max() # return output output = tmo.process(hdr.astype('float32')) return output
def main(): scene = "./images/scene1/" bgImage = cv2.imread(scene + "bg.png", cv2.IMREAD_COLOR) obj = cv2.imread(scene + "obj1.png", cv2.IMREAD_UNCHANGED) objQuant = quantize(obj[:, :, 0:3], 4) objQuant = cv2.cvtColor(objQuant, cv2.COLOR_RGB2RGBA) objQuant[:, :, 3] = obj[:, :, 3] out = mergeImages(bgImage, objQuant, 0.75) obj = cv2.imread(scene + "obj2.png", cv2.IMREAD_UNCHANGED) objQuant = quantize(obj[:, :, 0:3], 4) objQuant = cv2.cvtColor(objQuant, cv2.COLOR_RGB2RGBA) objQuant[:, :, 3] = obj[:, :, 3] out = mergeImages(out, objQuant, 0.75) cv2.imshow('Merge quantized', out) cv2.imwrite(scene + 'scene1answer.png', out) debevec = cv2.createMergeDebevec() merged = debevec.process([bgImage, out], np.array([0.15, 0.15], dtype=np.float32)) tonemapper = cv2.createTonemapReinhard( 0.5, 0, 0, 0) #Gamma, intensity, light_adapt, color_adapt tonemapped = tonemapper.process(merged) cv2.imshow("Merge and mapped reinhard quantized", tonemapped) out = cv2.convertScaleAbs(tonemapped, alpha=(255.0)) out = out.astype('uint8') cv2.imwrite(scene + 'scene1.png', out)
def run(config, model): SDR = get_test_data(config.test_path) print(SDR.shape) rs = model.predict(SDR) out = rs[0] tonemap = cv2.createTonemapReinhard() out = tonemap.process(out.copy()) cv2.imwrite(os.path.join(config.test_path, 'hdr.jpg'), np.uint8(out * 255))
def calc_scene_hdr_psnr(): scenes_obj = parse_json_file(args.scene_map_fp) scenes_psnr = {} for i, scene in enumerate(scenes_obj): scene_fd = os.path.dirname(scene['ldr_fps'][0]) scene_rend_fp = scene['rend_fp'] scene_cv_fp = os.path.join(scene_fd, '{}_cv-hdr.jpg'.format(scene['ldr_fd'])) # scene_ldr_fps = scene['ldr_fps'] scene_exptime_fp = get_scene_exptime_fp(scene_fd) print('Processing: ' + scene_fd) print(' scene_rend_fp (r): ' + scene_rend_fp) rend_hdr_img = cv2.imread(scene_rend_fp) # Render HDR image using OpenCV if args.force or not os.path.isfile(scene_cv_fp): print(' scene_cv_fp (w): ' + scene_cv_fp) ldr_imgs = [] ldr_exptimes = [] with open(scene_exptime_fp, 'r') as exptimes_file: for line in exptimes_file: vals = line.split(',') ldr_imgs.append( cv2.imread( os.path.join(scene_fd, vals[0].split('/')[-1]))) ldr_exptimes.append(float(vals[1])) ldr_exptimes = np.array(ldr_exptimes, dtype=np.float32) # Estimate Camera response function, merge exposures calib_debevec = cv2.createCalibrateDebevec() resp_debevec = calib_debevec.process(ldr_imgs, ldr_exptimes) merge_debevec = cv2.createMergeDebevec() hdr_debevec = merge_debevec.process(ldr_imgs, ldr_exptimes, resp_debevec) # Tone mapping tone_map = cv2.createTonemapReinhard(1.5, 0, 0, 0) cv_hdr_img = tone_map.process(hdr_debevec) cv2.imwrite(scene_cv_fp, cv_hdr_img * 255.0) else: print(' scene_cv_fp (r): ' + scene_cv_fp) cv_hdr_img = cv2.imread(scene_cv_fp) # Calculate PSNR cv_hdr_img = cv2.resize(cv_hdr_img, dsize=(rend_hdr_img.shape[1], rend_hdr_img.shape[0]), interpolation=cv2.INTER_CUBIC) scene_rend_fn = scene_rend_fp.split('/')[-1] scenes_psnr[scene_rend_fn] = img_psnr(cv_hdr_img, rend_hdr_img) return scenes_psnr
def show(filename, fileID): # Get Raw Data img = merge_raw(filename, 540, 960) scale = np.max(img) s = downsample(img) # Tone-Mapping tonemap_night = cv2.createTonemapReinhard(1, -4, 0.7, 0.7) ldrh = tonemap_night.process((np.float32(s / scale))) # Denoising ldrh = cv2.fastNlMeansDenoisingColored((ldrh * 255).astype(np.uint8), searchWindowSize=15, templateWindowSize=3, h=1) / 255 # Adjust White Balance ldrh = grey_world(ldrh) output = ldrh # Bi-linear Demosaicing sd = debayer(img) # Tone-Mapping tonemap_night = cv2.createTonemapReinhard(1, -4, 0.7, 0.7) ldrh = tonemap_night.process((np.float32(sd / scale))) # Adjust White Balance ldrh = grey_world(ldrh) output = np.concatenate( (cv2.resize(output, (output.shape[1] * 2, output.shape[0] * 2)), ldrh), axis=0) cv2.imwrite('{}/output_{}.png'.format(TARGET_DIRECTORY, fileID), output[..., ::-1] * 255)
def tMO(file,name): #tonemapping the file try: if (name == 'reinhard'): tom = cv2.createTonemapReinhard() if (name == 'mantiuk'): tom = cv2.createTonemapMantiuk() if (name == 'drago'): tom = cv2.createTonemapDrago() if (name == 'linear'): tom = cv2.createTonemap() except: print('ToneMapping Error') ldr = tom.process(file) return ldr
def tone_map(img, tmo_name): if (tmo_name == 'exposure'): tmo = Exposure(gamma=opt.gamma, stops=opt.stops) if (tmo_name == 'reinhard'): tmo = cv2.createTonemapReinhard(intensity=-1.0, light_adapt=0.8, color_adapt=0.0) elif tmo_name == 'mantiuk': tmo = cv2.createTonemapMantiuk(saturation=1.0, scale=0.75) elif tmo_name == 'drago': tmo = cv2.createTonemapDrago(saturation=1.0, bias=0.85) elif tmo_name == 'durand': tmo = cv2.createTonemapDurand(contrast=3, saturation=1.0, sigma_space=8, sigma_color=0.4) return tmo.process(img)
def __init__(self, intensity=-1.0, light_adapt=0.8, color_adapt=0.0, gamma=2.0, randomize=False): if randomize: gamma = uniform(1.8, 2.2) intensity = uniform(-1.0, 1.0) light_adapt = uniform(0.8, 1.0) color_adapt = uniform(0.0, 0.2) self.op = cv2.createTonemapReinhard( gamma=gamma, intensity=intensity, light_adapt=light_adapt, color_adapt=color_adapt)
def main(): #读取多张曝光的图像 images,times = readImagesAndTimes() #对齐图像 alignMTB = cv2.createAlignMTB() alignMTB.process(images, images) #恢复相机响应函数 calibrateDebevec = cv2.createCalibrateDebevec() responseDebevec = calibrateDebevec.process(images, times) # 将多张图像融合成hdr mergeDebevec = cv2.createMergeDebevec() hdrDebevec = mergeDebevec.process(images, times, responseDebevec) # 保存融合结果,可用ps打开 cv2.imwrite("hdrDebevec.hdr", hdrDebevec) # Tonemap using Drago's method to obtain 24-bit color image tonemapDrago = cv2.createTonemapDrago(1.0, 0.7) ldrDrago = tonemapDrago.process(hdrDebevec) ldrDrago = 3 * ldrDrago cv2.imwrite("ldr-Drago.jpg", ldrDrago * 255) # Tonemap using Durand's method obtain 24-bit color image tonemapDurand = cv2.createTonemapDurand(1.5,4,1.0,1,1) ldrDurand = tonemapDurand.process(hdrDebevec) ldrDurand = 3 * ldrDurand cv2.imwrite("ldr-Durand.jpg", ldrDurand * 255) # Tonemap using Reinhard's method to obtain 24-bit color image tonemapReinhard = cv2.createTonemapReinhard(1.5, 0,0,0) ldrReinhard = tonemapReinhard.process(hdrDebevec) cv2.imwrite("ldr-Reinhard.jpg", ldrReinhard * 255) # Tonemap using Mantiuk's method to obtain 24-bit color image tonemapMantiuk = cv2.createTonemapMantiuk(2.2,0.85, 1.2) ldrMantiuk = tonemapMantiuk.process(hdrDebevec) ldrMantiuk = 3 * ldrMantiuk cv2.imwrite("ldr-Mantiuk.jpg", ldrMantiuk * 255)
def tone_mapping_Reinhard(img_file, gamma = 1.5, intensity = 0, light_adapt = 0, color_adapt = 0): ''' tonemapDrago = cv2.createTonemapDrago(2, 2) ldrDrago = tonemapDrago.process(image_output) ldrDrago = 3 * ldrDrago ldrDrago = ldrDrago * 256.0 - 0.5 tonemapDurand = cv2.createTonemapDurand(8,4,1.0,1,1) ldrDurand = tonemapDurand.process(image_output) ldrDurand = 3 * ldrDurand tonemapMantiuk = cv2.createTonemapMantiuk(2.2,0.85, 1.2) ldrMantiuk = tonemapMantiuk.process(image_output) ldrMantiuk = 3 * ldrMantiuk ''' img = imread(img_file).astype(np.float32)/255 tonemapReinhard = cv2.createTonemapReinhard(gamma, intensity, # [-8, 8] light_adapt, # [0, 1] color_adapt) # [0, 1] init_time = time.time() ldrReinhard = tonemapReinhard.process(img) ldrReinhard = ldrReinhard * 255.0 np.putmask(ldrReinhard, ldrReinhard > 255, 255) np.putmask(ldrReinhard, ldrReinhard < 0, 0) ldrReinhard = ldrReinhard.astype(np.uint8) print("passed time = {}".format(time.time()-init_time)) plt.figure(figsize = (10,10)) plt.imshow(ldrReinhard) misc.imsave("G:\\ECE516\\HDR team\\Reinhard.jpg",ldrReinhard) plt.show()
def __init__(self, ip_pi): QThread.__init__(self) self.threadID = 1 self.name = "ImgThread" self.window = None self.saveOn = False self.mergeMertens = cv2.createMergeMertens(1,1,1) #* self.mergeMertens = cv2.createMergeMertens() # print("Contrast:",self.mergeMertens.getContrastWeight()) # print("Saturation:",self.mergeMertens.getSaturationWeight()) # print("Exposure:",self.mergeMertens.getExposureWeight()) self.mergeDebevec = cv2.createMergeDebevec() self.calibrateDebevec = cv2.createCalibrateDebevec() self.toneMap = cv2.createTonemapReinhard() # self.claheProc = cv2.createCLAHE(clipLimit=1, tileGridSize=(8,8)) # self.simpleWB = cv2.xphoto.createSimpleWB() # self.simpleWB = cv2.xphoto.createGrayworldWB() # self.wb= False # self.equalize = False # self.clahe = False # self.clipLimit = 1. self.invgamma = np.empty((1,256), np.uint8) for i in range(256): self.invgamma[0,i] = np.clip(pow(i / 255.0, 0.45) * 255.0, 0, 255) self.gamma = np.empty((1,256), np.uint8) for i in range(256): self.gamma[0,i] = np.clip(pow(i / 255.0, 2.2) * 255.0, 0, 255) self.reduceFactor = 1; self.ip_pi = ip_pi self.hflip = False self.vflip = False self.table=None self.doCalibrate = False try: npz = np.load("calibrate.npz") self.table = npz['table'] except Exception as e: pass
def reinhard_hdr(image_names, algo='debevec', exposures=None, gamma=1.0, intensity=0.0, light_adapt=1.0, color_adapt=0.0, output=None): """ Create an HDR image from the supplied images. :param images: List of images to process. :return: Returns name of new HDR image. """ hdr_img = process_image(image_names, exposures, algo) tonemap_reinhard = cv2.createTonemapReinhard( gamma, intensity, light_adapt, color_adapt ) ldr_reinhard = tonemap_reinhard.process(hdr_img) img_out = get_image_output(image_names[1], output) cv2.imwrite(img_out, ldr_reinhard * 255)
def main(): # input multiple exposure images folderNM = './img/europe/' fileNM = ["low.jpg", "middle.jpg", "high.jpg"] imgs = [cv2.imread(folderNM + fn) for fn in fileNM] # auto discover exposure time from Exif information of input image file exposureTimes = np.array([getExifInfo(folderNM + fn) for fn in fileNM], dtype=np.float32) # if Exif information is None, you should set exposure time manually # exposureTimes = np.array([15.0, 2.5, 0.25, 0.0333], dtype=np.float32) # Estimate camera response function (CRF) mergeDebevec = cv2.createMergeDebevec() hdr = mergeDebevec.process(imgs, times=exposureTimes.copy()) hdr[hdr < 0] = 0 cv2.imwrite("res/hdrDebevec.hdr", hdr) # linear res1 = 255 * hdr / hdr.max() # gamma res2 = 255 * (hdr / hdr.max())**0.2 # reinhardTM_global tonemap = cv2.createTonemapReinhard(gamma=1.5) res3 = tonemap.process(hdr.copy()) res3 = percentileCut(res3, 0.5, 99.9) * 255 cv2.imshow('result_linear', res1.astype(np.uint8)) cv2.imshow('result_gamma', res2.astype(np.uint8)) cv2.imshow('result_reinhard', res3.astype(np.uint8)) cv2.waitKey(0) cv2.destroyAllWindows() cv2.imwrite("res/tonemappedImg.png", res3)
def createHDR(self): """ Numpy array of exposure times from exif data """ for image in self.image_paths: p = Photo(image) self.exposure_times.append(p.exifData()) times_np = np.asarray(self.exposure_times, dtype=np.float32) # Align Images alignMTB = cv.createAlignMTB() alignMTB.process(self.im_list, self.im_list) # Find Camera Response Curve calibrateDebevec = cv.createCalibrateDebevec() responseDebevec = calibrateDebevec.process(self.im_list, times_np) # Merge Images mergeDebevec = cv.createMergeDebevec() hdrDebevec = mergeDebevec.process(self.im_list, times_np, responseDebevec) # Generate HDR image and LDR tone mapped preview cv.imwrite("hdr.hdr", hdrDebevec) toneMapReinhard = cv.createTonemapReinhard(1.5, 0.0) ldrReinhard = toneMapReinhard.process(hdrDebevec) cv.imwrite("hdr_preview.jpg", ldrReinhard * 255)
def HDR_TMO_Reinhard(fn, g): hdr_image = cv.imread(fn, cv.IMREAD_ANYDEPTH) tonemap = cv.createTonemapReinhard(gamma=g) result = tonemap.process(hdr_image.copy()) result_8bit = np.clip(result * 255, 0, 255).astype('uint8') cv.imwrite("img/TMO_Reinhard.jpg", result_8bit)
def reinhard(hdr): tonemap = cv2.createTonemapReinhard() ldr = tonemap.process(hdr) cv2.imwrite('{}.png'.format('reinhard.png'), ldr * 255)
raw = rawpy.imread(in_path) input_images[str(ratio)[0:2]][ind] = np.expand_dims(pack_raw(raw), axis=0) * ratio print(gt_path) ''' # method 1: read raw hdr file in rgbe format gt_file = open(gt_path, 'rb') header = gt_file.read(78) gt_bytes = gt_file.read() gt_file.close() gt_images[ind] = np.expand_dims(np.float32(pack_hdr(gt_bytes)/255.0),axis = 0)# 8-bit, 4 channels ''' # method 2: use Reinhard tonemapped image as gt hdr = cv2.imread(gt_path, -1) tonemapReinhard = cv2.createTonemapReinhard(3.0, -2.5, 0, 0) gt_images[ind] = np.expand_dims(tonemapReinhard.process(hdr), axis=0) #crop H = input_images[str(ratio)[0:2]][ind].shape[1] W = input_images[str(ratio)[0:2]][ind].shape[2] xx = np.random.randint(0, W - ps) yy = np.random.randint(0, H - ps) input_patch = input_images[str(ratio)[0:2]][ind][:, yy:yy + ps, xx:xx + ps, :] gt_patch = gt_images[ind][:, yy * 2:yy * 2 + ps * 2, xx * 2:xx * 2 + ps * 2, :] if np.random.randint(2, size=1)[0] == 1: # random flip input_patch = np.flip(input_patch, axis=1)
# tonemap all .npy images in current dir to .jpg using OpenCV Reinhard method import os import cv2 import numpy as np for f in os.listdir(os.getcwd()): if f.endswith('.npy'): hdr = np.load(f) hdr = hdr.astype('float32') hdr = (hdr - np.min(hdr)) / (np.max(hdr) - np.min(hdr)) grayscale = True if hdr.ndim == 3: if hdr.shape[2] == 3: # RGB image (H, W, 3) hdr = cv2.cvtColor(hdr, cv2.COLOR_RGB2BGR) grayscale = False elif hdr.shape[2] == 1: # grayscale image (H, W, 1) hdr = hdr[:, :, 0] if grayscale: hdr = np.stack([hdr, hdr, hdr], axis=2) tmo = cv2.createTonemapReinhard(intensity=-1.0, light_adapt=0.8, color_adapt=0.0) tonemapped = tmo.process(hdr) f_ = f.split('.')[0] + '.jpg' cv2.imwrite(f_, tonemapped * 255)
def tone_map(stack): stack = np.array(stack).squeeze(0).transpose(1, 2, 0) # Tonemap using Reinhard's method to obtain 24-bit color image tonemapReinhard = cv2.createTonemapReinhard(1.5, 0, 0, 0) ldrReinhard = tonemapReinhard.process(stack.copy()) return (ldrReinhard * 255).clip(0, 255).astype('uint8')
def tone_mapping_reinhard(): tonemapReinhard = cv2.createTonemapReinhard(1.5, 0, 0, 0) ldrReinhard = tonemapReinhard.process(hdrDebevec) return ldrReinhard * 255
def TonemapReinhard(file_path): im = cv2.imread(file_path, cv2.IMREAD_ANYDEPTH) tonemapReinhard = cv2.createTonemapReinhard(1.5, 0, 0, 0) ldrReinhard = tonemapReinhard.process(im) return ldrReinhard
# Convert to gray and get the mean value Gray = cv2.cvtColor(Raw, cv2.COLOR_BayerBG2GRAY) MeanGray = cv2.mean(Gray) # White balance WB = MeanGray[0] / MeanRGB B = HRGB[:, :, 0] * WB[0] G = HRGB[:, :, 1] * WB[1] R = HRGB[:, :, 2] * WB[2] HRGBwb = cv2.merge((B, G, R)) # Generate the tonemap image #ToneMap = cv2.createTonemapReinhard(gamma=0.8, intensity=+3, light_adapt=0.7) ToneMap = cv2.createTonemapReinhard(gamma=0.7, intensity=+3, light_adapt=0.6) ToneHRGBwb = ToneMap.process(np.float32(HRGBwb)) RGB = np.clip(ToneHRGBwb * 255, 0, 255).astype('uint8') # Apply a Contrast Limited Adaptive Histogram Equalization (CLAHE) clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) Bc = clahe.apply(RGB[:, :, 0]) Gc = clahe.apply(RGB[:, :, 1]) Rc = clahe.apply(RGB[:, :, 2]) RGBc = cv2.merge((Bc, Gc, Rc)) # Save image as JPEG cv2.imwrite(x + '.jpeg', RGBc) # Display image
cv2.imwrite("./images/HDR/ldr-Drago-example.jpg", ldrDrago * 255) cv2.imshow("ldr-Drago", ldrDrago) print("saved ldr-Drago.jpg") # Tonemap using Durand's method obtain 24-bit color image print("Tonemaping using Durand's method ... ") tonemapDurand = cv2.createTonemapDurand(1.5, 4, 1.0, 1, 1) ldrDurand = tonemapDurand.process(hdrDebevec) ldrDurand = 3 * ldrDurand cv2.imwrite("./images/HDR/ldr-Durand-example.jpg", ldrDurand * 255) cv2.imshow("ldrDurand", ldrDurand) print("saved ldr-Durand.jpg") # Tonemap using Reinhard's method to obtain 24-bit color image print("Tonemaping using Reinhard's method ... ") tonemapReinhard = cv2.createTonemapReinhard(1.5, 0, 0, 0) ldrReinhard = tonemapReinhard.process(hdrDebevec) cv2.imwrite("./images/HDR/ldr-Reinhard-example.jpg", ldrReinhard * 255) cv2.imshow("ldrReinhard", ldrReinhard) print("saved ldr-Reinhard.jpg") # Tonemap using Mantiuk's method to obtain 24-bit color image print("Tonemaping using Mantiuk's method ... ") tonemapMantiuk = cv2.createTonemapMantiuk(2.2, 0.85, 1.2) ldrMantiuk = tonemapMantiuk.process(hdrDebevec) ldrMantiuk = 3 * ldrMantiuk cv2.imwrite("./images/HDR/ldr-Mantiuk-example.jpg", ldrMantiuk * 255) cv2.imshow("ldrMantiuk", ldrMantiuk) print("saved ldr-Mantiuk.jpg") # Wait until a key pressed
print("Tonemaping using Drago's method ... ") tonemapDrago = cv2.createTonemapDrago(1.0, 0.7) ldrDrago = tonemapDrago.process(hdrDebevec) ldrDrago = 3 * ldrDrago cv2.imwrite("ldr-Drago.jpg", ldrDrago * 255) print("saved ldr-Drago.jpg") # Tonemap using Durand's method obtain 24-bit color image print("Tonemaping using Durand's method ... ") tonemapDurand = cv2.createTonemapDurand(1.5,4,1.0,1,1) ldrDurand = tonemapDurand.process(hdrDebevec) ldrDurand = 3 * ldrDurand cv2.imwrite("ldr-Durand.jpg", ldrDurand * 255) print("saved ldr-Durand.jpg") # Tonemap using Reinhard's method to obtain 24-bit color image print("Tonemaping using Reinhard's method ... ") tonemapReinhard = cv2.createTonemapReinhard(1.5, 0,0,0) ldrReinhard = tonemapReinhard.process(hdrDebevec) cv2.imwrite("ldr-Reinhard.jpg", ldrReinhard * 255) print("saved ldr-Reinhard.jpg") # Tonemap using Mantiuk's method to obtain 24-bit color image print("Tonemaping using Mantiuk's method ... ") tonemapMantiuk = cv2.createTonemapMantiuk(2.2,0.85, 1.2) ldrMantiuk = tonemapMantiuk.process(hdrDebevec) ldrMantiuk = 3 * ldrMantiuk cv2.imwrite("ldr-Mantiuk.jpg", ldrMantiuk * 255) print("saved ldr-Mantiuk.jpg")