Simple HDR image filter implementation

simpleHDR.py

import cv
import sys

input_img_name = sys.argv[1]
output_img_name = sys.argv[2]

input_img = cv.LoadImage(input_img_name, cv.CV_LOAD_IMAGE_COLOR)

# blur the image
dst = cv.CreateImage(cv.GetSize(input_img), input_img.depth, input_img.channels)
cv.Smooth(input_img, dst, cv.CV_GAUSSIAN, 3, 3)
#cv.SaveImage('blur_image.jpg', dst)


final_result = cv.CreateImage(cv.GetSize(input_img), input_img.depth,
        input_img.channels)

for row in xrange(input_img.height):
    for col in xrange(input_img.width):
        ib, ig, ir = input_img[row, col]
        db, dg, dr = dst[row, col]
        newb, newg, newr = 0, 0, 0
        if db / 255.0 <= 0.5:
            newb = 2 * (db / 255.0) * (ib / 255.0)
        else:
            newb = 1 - 2 * (1 - ib / 255.0) * (1 - db / 255.0)
        if dg / 255.0 <= 0.5:
            newg = 2 * (dg / 255.0) * (ig / 255.0)
        else:
            newg = 1 - 2 * (1 - ig / 255.0) * (1 - dg / 255.0)
        if dr / 255.0 <= 0.5:
            newr = 2 * (dr / 255.0) * (ir / 255.0)
        else:
            newr = 1 - 2  * (1 - ir / 255.0) * (1 - dr / 255.0)
        
        #print newb, newg, newr
        final_result[row, col] = (newb * 255, newg * 255, newr * 255)

laplace_img = cv.CreateImage(cv.GetSize(input_img), input_img.depth,
        input_img.channels)

#convert to gray scale image
#cv.CvtColor(final_result, laplace_img, cv.CV_BGR2GRAY)

#cv.Laplace(grayimg, laplace_img)
#sharpen the image
mask = [
        [0, -1, 0],
        [-1, 4, -1],
        [0, -1, 0]
        ]
for row in xrange(1, laplace_img.height - 1):
    for col in xrange(1, laplace_img.width - 1):
        sum_list = [0 for i in xrange(3)]
        for i in xrange(3):
            _sum = 0
            _sum += final_result[row - 1, col - 1][i] * mask[0][0]
            _sum += final_result[row - 1, col][i] * mask[0][1]
            _sum += final_result[row - 1, col + 1][i] * mask[0][2]
            _sum += final_result[row, col - 1][i] * mask[1][0]
            _sum += final_result[row, col][i] * mask[1][1]
            _sum += final_result[row, col + 1][i] * mask[1][2]
            _sum += final_result[row + 1, col - 1][i] * mask[2][0]
            _sum += final_result[row + 1, col][i] * mask[2][1]
            _sum += final_result[row + 1, col + 1][i] * mask[2][2]
            sum_list[i] = _sum
        laplace_img[row, col] = tuple(sum_list)

for row in xrange(final_result.height):
    for col in xrange(final_result.width):
        bl, gl, rl = laplace_img[row, col]
        b, g, r = final_result[row, col]
        final_result[row, col] = (b + bl, g + gl, r + rl)

cv.SaveImage(output_img_name, final_result)

You need to install opencv's python binding.

usage: simpleHDR.py input_image_name output_image_name

the left side is the original image, the right side is the image after processing...