def HDR(_imgs_nx1, _times_nx1, method=Debevec):
assert _imgs_nx1.dtype == np.uint8 and _times_nx1.dtype == np.float32, "Type Error"
assert len(_imgs_nx1) == len(
_times_nx1) and len(_times_nx1) > 0, "Len Error"
if method == Debevec:
CalibrateDebevec = cv2.createCalibrateDebevec(samples=70, random=True)
crf = CalibrateDebevec.process(src=_imgs_nx1, times=_times_nx1)
merge_debvec = cv2.createMergeDebevec()
hdr_img = merge_debvec.process(src=_imgs_nx1,
times=_times_nx1,
response=crf)
tonemap = cv2.createTonemapDurand(gamma=1.4)
res_img = tonemap.process(hdr_img.copy())
return crf, hdr_img, res_img
if method == Robertson:
CalibrateRobertson = cv2.createCalibrateRobertson()
crf = CalibrateRobertson.process(src=_imgs_nx1, times=_times_nx1)
merge_robertson = cv2.createMergeRobertson()
hdr_img = merge_robertson.process(src=_imgs_nx1,
times=_times_nx1,
response=crf)
#local tonermap
tonemap = cv2.createTonemapDurand(gamma=1.4)
res_img = tonemap.process(hdr_img.copy())
return crf, hdr_img, res_img
if method == Mertens:
merge_mertens = cv2.createMergeMertens()
res_img = merge_mertens.process(_imgs_nx1)
# cv2.imshow("ss", res_img)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
# res_mertens_8bit = np.clip(res_img*255, 0, 255).astype('uint8')
# cv2.imwrite("PyFusion.png", res_mertens_8bit)
return res_img
def Rendering(img_list,exposure_times):
# Merge exposures to HDR image
merge_debvec = cv2.createMergeDebevec()
hdr_debvec = merge_debvec.process(img_list, times=exposure_times.copy())
merge_robertson = cv2.createMergeRobertson()
hdr_robertson = merge_robertson.process(img_list, times=exposure_times.copy())
# Tonemap HDR image
tonemap1 = cv2.createTonemapDurand(gamma=2.2)
res_debvec = tonemap1.process(hdr_debvec.copy())
tonemap2 = cv2.createTonemapDurand(gamma=1.3)
res_robertson = tonemap2.process(hdr_robertson.copy())
# Exposure fusion using Mertens
merge_mertens = cv2.createMergeMertens()
res_mertens = merge_mertens.process(img_list)
# Convert datatype to 8-bit and save
res_debvec_8bit = np.clip(res_debvec*255, 0, 255).astype('uint8')
res_robertson_8bit = np.clip(res_robertson*255, 0, 255).astype('uint8')
res_mertens_8bit = np.clip(res_mertens*255, 0, 255).astype('uint8')
cv2.imwrite("ldr_debvec.jpg", res_debvec_8bit)
cv2.imwrite("ldr_robertson.jpg", res_robertson_8bit)
cv2.imwrite("fusion_mertens.jpg", res_mertens_8bit)
def main():
global client, img
images = []
delta = 25
set_param('auto_exposure', True)
set_param('auto_frame_rate', True)
ev_auto = get_param('exposure')
print("EV_auto: {0}".format(ev_auto))
set_param('auto_exposure', False)
# exposure = [ev_auto - delta, ev_auto, ev_auto + delta]
exposure = [ev_auto - delta, ev_auto + delta]
for ev in exposure:
t = time.time()
set_param('exposure', int(ev))
delta_t = time.time() - t
print("time: {0}".format(delta_t))
time.sleep(1)
name = 'image exposure :' + str(ev)
images.append(img.copy())
# EV = log2(f^2 / t)
# et = math.pow(f, 2.0) / math.pow(2.0, ev)
cv2.imshow(name, img.copy())
exposure_times = np.array(exposure, dtype=np.float32)
# debvec
merge_debvec = cv2.createMergeDebevec()
hdr_debvec = merge_debvec.process(images, times=exposure_times.copy())
# robertson
merge_robertson = cv2.createMergeRobertson()
hdr_robertson = merge_robertson.process(images,
times=exposure_times.copy())
tonemap1 = cv2.createTonemapDurand(gamma=2.2)
res_debvec = tonemap1.process(hdr_debvec.copy())
tonemap2 = cv2.createTonemapDurand(gamma=1.3)
res_robertson = tonemap2.process(hdr_robertson.copy())
# mertens not
merge_mertens = cv2.createMergeMertens()
res_mertens = merge_mertens.process(images)
cv2.imshow('debvec', res_debvec)
cv2.imshow('robertson', res_robertson)
cv2.imshow('mertens', res_mertens)
while True:
key = cv2.waitKey(1) & 0xff
if key == ord('q'):
break
def CRF_merge_Robertson(paths, exposures):
# Loading exposure images into a list
img_fn = paths
img_list = [cv.imread(str(fn)) for fn in img_fn]
exposure_times = np.array(exposures, dtype=np.float32)
# Merge exposures to HDR image
merge_Robertson = cv.createMergeRobertson()
hdr_Robertson = merge_Robertson.process(img_list,
times=exposure_times.copy())
# Tonemap HDR image
tonemap = cv.createTonemapMantiuk()
res_Robertson = tonemap.process(hdr_Robertson.copy())
# Convert datatype to 8-bit and save
res_Robertson_8bit = np.clip(res_Robertson * 255, 0, 255).astype('uint8')
cv.imwrite("img/LDR_robertson.jpg", res_Robertson_8bit)
import cv2 as cv
import numpy as np
# Loading exposure images into a list
img_fn = ["img0.jpg", "img1.jpg", "img2.jpg", "img3.jpg"]
img_list = [cv.imread(fn) for fn in img_fn]
exposure_times = np.array([15.0, 2.5, 0.25, 0.0333], dtype=np.float32)
# Merge exposures to HDR image
merge_debevec = cv.createMergeDebevec()
hdr_debevec = merge_debevec.process(img_list, times=exposure_times.copy())
merge_robertson = cv.createMergeRobertson()
hdr_robertson = merge_robertson.process(img_list, times=exposure_times.copy())
# Tonemap HDR image
tonemap1 = cv.createTonemap(gamma=2.2)
res_debevec = tonemap1.process(hdr_debevec.copy())
tonemap2 = cv.createTonemap(gamma=1.3)
res_robertson = tonemap2.process(hdr_robertson)
# Exposure fusion using Mertens
merge_mertens = cv.createMergeMertens()
res_mertens = merge_mertens.process(img_list)
# Convert datatype to 8-bit and save
res_debevec_8bit = np.clip(res_debevec * 255, 0, 255).astype('uint8')
res_robertson_8bit = np.clip(res_robertson * 255, 0, 255).astype('uint8')
res_mertens_8bit = np.clip(res_mertens * 255, 0, 255).astype('uint8')
cv.imwrite("hdr_debevec.jpg", res_debevec_8bit)
cv.imwrite("hdr_robertson.jpg", res_robertson_8bit)
cv.imwrite("fusion_mertens.jpg", res_mertens_8bit)
def recover_camera_response(inputFolder = '.',
exposureListFile = None,
outputResponseCurve = "camera_response.spi1d",
outputResponseFormat = "spi1d",
calibrationApproach = "berkeley",
mergeExposures = False,
mergedExposuresOutput = None,
verbose = False,
robertsonMaxIter = 30.0,
robertsonThreshold = 0.01,
berkeleyLambda = 20.0,
berkeleySamples = 1024,
berkeleySamplePlacementRandom = False):
extensions = generalExtensions
if exposureListFile:
with open(exposureListFile, 'r') as f:
exposuresList = f.readlines()
exposuresList = [x.strip() for x in exposuresList if len(x) > 1]
imageUris = [x.split(' ')[0] for x in exposuresList]
exposure_times = [1.0/float(x.split(' ')[1]) for x in exposuresList]
else:
imageUris = sorted( os.listdir( inputFolder ) )
imageUris = [x for x in imageUris if (os.path.splitext(x)[-1].lower()[1:] in extensions) and (x[0] != '.')]
if verbose:
print( imageUris )
cwd = os.getcwd()
os.chdir( inputFolder )
exposure_times = [0]*len(imageUris)
for i in range(len(imageUris)):
exposure_times[i] = getShutterSpeed( imageUris[i], verbose=verbose )
# List has to be sorted from longest shutter speed to shortest for opencv functions to work
exposure_times, imageUris = (list(x) for x in zip(*sorted(zip(exposure_times, imageUris))))
imageUris.reverse()
exposure_times.reverse()
exposure_times = np.array(exposure_times, dtype=np.float32)
if verbose:
for exposure in zip(exposure_times, imageUris):
print( "Image : %s, Shutter speed : %2.6f" % (exposure[1], exposure[0]) )
img_list = [cv2.imread(fn) for fn in imageUris ]
if not exposureListFile:
os.chdir( cwd )
if calibrationApproach == "robertson":
merge = cv2.createMergeRobertson()
calibrate = cv2.createCalibrateRobertson()
calibrate.setMaxIter(robertsonMaxIter)
calibrate.setThreshold(robertsonThreshold)
if verbose:
print( calibrationApproach )
print( "\tmax iter : %d" % robertsonMaxIter )
print( "\tthreshold : %f" % robertsonThreshold )
else:
merge = cv2.createMergeDebevec()
calibrate = cv2.createCalibrateDebevec()
calibrate.setLambda(berkeleyLambda)
calibrate.setSamples(berkeleySamples)
calibrate.setRandom(berkeleySamplePlacementRandom)
if verbose:
print( calibrationApproach )
print( "\tlambda : %3.2f" % berkeleyLambda )
print( "\tsamples : %d" % berkeleySamples )
print( "\trandom : %s" % berkeleySamplePlacementRandom )
if verbose:
print( "recovering camera response" )
curve = calibrate.process(img_list, times=exposure_times)
if verbose:
print( "writing camera response - %s, %s" % (outputResponseFormat, outputResponseCurve) )
if outputResponseFormat == "spi1d":
with open(outputResponseCurve, "w") as f:
f.write( "Version 1\n" )
f.write( "From 0.000000 1.000000\n" )
f.write( "Length 256\n" )
f.write( "Components 3\n" )
f.write( "{\n" )
for i in range(len(curve)):
f.write( "%3.6f %3.6f %3.6f\n" % (curve[i][0][0]*0.18, curve[i][0][1]*0.18, curve[i][0][2]*0.18) )
f.write( "}\n" )
else:
with open(outputResponseCurve, "w") as f:
for i in range(len(curve)):
f.write( "%3.6f %3.6f %3.6f\n" % (curve[i][0][0], curve[i][0][1], curve[i][0][2]) )
if mergedExposuresOutput:
if verbose:
print( "merging exposures" )
hdr = merge.process(img_list, times=exposure_times.copy(), response=curve.copy())
cv2.imwrite(mergedExposuresOutput, hdr)
import cv2 import numpy as np # 第一阶段只是将所有图像加载到列表中。此外，我们将需要常规HDR算法的曝光时间。注意数据类型，因为图像应为1通道或3通道8位（np.uint8），曝光时间需要为float32，以秒为单位。 # Loading exposure images into a list img_fn = ["1tl.jpg", "2tr.jpg", "3bl.jpg", "4br.jpg"] img_list = [cv2.imread(fn) for fn in img_fn] exposure_times = np.array([15.0, 2.5, 0.25, 0.0333], dtype=np.float32) # Merge exposures to HDR image # 在这个阶段，我们将曝光序列合并成一个HDR图像，显示了我们在OpenCV中的两种可能性。第一种方法是Debvec，第二种是Robertson。请注意，HDR图像的类型为float32，而不是uint8，因为它包含所有曝光图像的完整动态范围。 merge_debvec = cv2.createMergeDebevec() hdr_debvec = merge_debvec.process(img_list, times=exposure_times.copy()) merge_robertson = cv2.createMergeRobertson() hdr_robertson = merge_robertson.process(img_list, times=exposure_times.copy()) # Tonemap HDR image # 我们将32位浮点HDR数据映射到范围[0..1]。实际上，在某些情况下，值可能大于1或低于0，所以注意我们以后不得不剪切数据，以避免溢出。 tonemap1 = cv2.createTonemapDurand(gamma=2.2) res_debvec = tonemap1.process(hdr_debvec.copy()) tonemap2 = cv2.createTonemapDurand(gamma=1.3) res_robertson = tonemap2.process(hdr_robertson.copy()) # Exposure fusion using Mertens # 这里我们展示了一种可以合并曝光图像的替代算法，我们不需要曝光时间。我们也不需要使用任何tonemap算法，因为Mertens算法已经给出了[0..1]范围内的结果。 merge_mertens = cv2.createMergeMertens() res_mertens = merge_mertens.process(img_list) # Convert datatype to 8-bit and save
images, exposTimes = alignment.process(image_list,exposTimes,'SIFT')
print(len(images))
exposTimes = np.array(exposTimes,dtype=np.float32) #convert to numpy float
# print('exposure time:', exposTimes)
# restore camera response
calibrateDebevec = cv2.createCalibrateDebevec()
responseDebevec = calibrateDebevec.process(images, times=exposTimes) #获得CRF
mergeDebevec = cv2.createMergeDebevec()
hdrDebevec = mergeDebevec.process(images, times=exposTimes.copy(), response=responseDebevec.copy())
#
# calibrateRobertson = cv2.createCalibrateRobertson()
# responseRobertson = calibrateRobertson.process(images, times=exposTimes)
mergeRobertson = cv2.createMergeRobertson()
hdrRobertson = mergeRobertson.process(images, times=exposTimes.copy())#, response=responseRobertson.copy())
hdrMyDebevec = Debevec.process(images, exposTimes)
myRobHdr = Robertson.Robertson()
hdrMyRobertson = myRobHdr.process(images, exposTimes)
# # Save HDR image.
cv2.imwrite("./res/deb/hdrDebevec.hdr", hdrDebevec)
cv2.imwrite("./res/rob/hdrRobertson.hdr", hdrRobertson)
cv2.imwrite("./res/MyDeb/hdrMyDebevec.hdr", hdrMyDebevec)
cv2.imwrite("./res/MyRob/hdrMyRobertson.hdr", hdrMyRobertson)
