OpenCV转换HDR图像与源码分析

这篇具有很好参考价值的文章主要介绍了OpenCV转换HDR图像与源码分析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

我们常见的图像位深一般是8bit,颜色范围[0, 255],称为标准动态范围SDR(Standard Dynamic Range)。SDR的颜色值有限,如果要图像色彩更鲜艳,那么就需要10bit,甚至12bit,称为高动态范围HDR(High Dynamic Range)。OpenCV有提供SDR转HDR的方法,而逆转换是通过Tone mapping实现。

我们先看下SDR与HDR图像的对比,如下图所示:

OpenCV转换HDR图像与源码分析
SDR图像
OpenCV转换HDR图像与源码分析
HDR图像

 

一、核心函数

在OpenCV的photo模块提供SDR与HDR互转,还有图像曝光融合。 

1、SDR转HDR

HDR算法需要CRF摄像头响应函数,计算CRF示例代码如下:

Mat image;
Mat response;
vector<float> times;
Ptr<CalibrateDebevec> calibrate = createCalibrateDebevec();
calibrate->process(image, response, times);

得到CRF响应函数后,使用MergeDebevec函数来转换HDR图像,C++代码:

Mat hdr;
Ptr<MergeDebevec> merge_debevec = createMergeDebevec();
merge_debevec->process(image, hdr, times, response);

java版本代码:

Mat hdr = new Mat();
MergeDebevec mergeDebevec = Photo.createMergeDebevec();
mergeDebevec.process(image, hdr, matTime);

 python版本代码:

merge_debevec = cv.createMergeDebevec()
hdr = merge_debevec.process(image, time, response)

2、HDR转SDR

HDR逆转SDR是通过Tonemap函数实现,其中2.2为Gamma矫正系数,C++代码如下:

Mat sdr;
float gamma = 2.2f;
Ptr<Tonemap> tonemap = createTonemap(gamma);
tonemap->process(hdr, sdr);

 java版本代码:

Mat ldr = new Mat();
Tonemap tonemap = Photo.createTonemap(2.2f);
tonemap.process(hdr, ldr);

python版本代码:

tonemap = cv.createTonemap(2.2)
ldr = tonemap.process(hdr)

3、图像曝光

在OpenCV中,使用MergeMertens进行图像的曝光融合,C++代码:

Mat exposure;
Ptr<MergeMertens> merge_mertens = createMergeMertens();
merge_mertens->process(image, exposure);

java版本代码:

Mat exposure = new Mat();
MergeMertens mergeMertens = Photo.createMergeMertens();
mergeMertens.process(image, exposure);

 python版本代码:

merge_mertens = cv.createMergeMertens()
exposure = merge_mertens.process(image)

二、实现代码

1、SDR转HDR源码

HDR图像转换的源码位于opencv/modules/photo/src/merge.cpp,首先是createMergeDebevec函数使用makePtr智能指针包裹:

Ptr<MergeDebevec> createMergeDebevec()
{
    return makePtr<MergeDebevecImpl>();
}

核心代码在于MergeDebevecImpl类的process(),具体如下:

class MergeDebevecImpl CV_FINAL : public MergeDebevec
{
public:
    MergeDebevecImpl() :
        name("MergeDebevec"),
        weights(triangleWeights())
    {}

    void process(InputArrayOfArrays src, OutputArray dst, InputArray _times, InputArray input_response) CV_OVERRIDE
    {
        CV_INSTRUMENT_REGION();

        std::vector<Mat> images;
        src.getMatVector(images);
        Mat times = _times.getMat();

        CV_Assert(images.size() == times.total());
        checkImageDimensions(images);
        CV_Assert(images[0].depth() == CV_8U);

        int channels = images[0].channels();
        Size size = images[0].size();
        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);

        dst.create(images[0].size(), CV_32FCC);
        Mat result = dst.getMat();

        Mat response = input_response.getMat();

        if(response.empty()) {
            response = linearResponse(channels);
            response.at<Vec3f>(0) = response.at<Vec3f>(1);
        }

        Mat log_response;
        log(response, log_response);
        CV_Assert(log_response.rows == LDR_SIZE && log_response.cols == 1 &&
                  log_response.channels() == channels);

        Mat exp_values(times.clone());
        log(exp_values, exp_values);

        result = Mat::zeros(size, CV_32FCC);
        std::vector<Mat> result_split;
        split(result, result_split);
        Mat weight_sum = Mat::zeros(size, CV_32F);
        // 图像加权平均
        for(size_t i = 0; i < images.size(); i++) {
            std::vector<Mat> splitted;
            split(images[i], splitted);

            Mat w = Mat::zeros(size, CV_32F);
            for(int c = 0; c < channels; c++) {
                LUT(splitted[c], weights, splitted[c]);
                w += splitted[c];
            }
            w /= channels;

            Mat response_img;
            LUT(images[i], log_response, response_img);
            split(response_img, splitted);
            for(int c = 0; c < channels; c++) {
                result_split[c] += w.mul(splitted[c] - exp_values.at<float>((int)i));
            }
            weight_sum += w;
        }
        weight_sum = 1.0f / weight_sum;

        for(int c = 0; c < channels; c++) {
            result_split[c] = result_split[c].mul(weight_sum);
        }
        // 融合
        merge(result_split, result);
        // 求对数
        exp(result, result);
    }


protected:
    String name;
    Mat weights;
};

这里MergeDebevecImpl继承MergeDebevec父类,最终是继承Algorithm抽象类,位于photo.hpp:

class CV_EXPORTS_W MergeExposures : public Algorithm
{
public:

    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
                                 InputArray times, InputArray response) = 0;
};


class CV_EXPORTS_W MergeDebevec : public MergeExposures
{
public:
    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
                                 InputArray times, InputArray response) CV_OVERRIDE = 0;
    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst, InputArray times) = 0;
};

2、HDR转SDR源码

前面我们有谈到,HDR转SDR是通过ToneMapping色调映射实现。位于photo模块的tonemap.cpp,入口是createTonemap(),也是使用智能指针包裹:

Ptr<Tonemap> createTonemap(float gamma)
{
    return makePtr<TonemapImpl>(gamma);
}

接着我们继续看TonemapImpl核心代码:

class TonemapImpl CV_FINAL : public Tonemap
{
public:
    TonemapImpl(float _gamma) : name("Tonemap"), gamma(_gamma)
    {}

    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
    {
        Mat src = _src.getMat();
        Mat dst = _dst.getMat();

        double min, max;
        // 获取图像像素最小值与最大值
        minMaxLoc(src, &min, &max);
        if(max - min > DBL_EPSILON) {
            dst = (src - min) / (max - min);
        } else {
            src.copyTo(dst);
        }
        // 幂运算,指数为gamma的倒数
        pow(dst, 1.0f / gamma, dst);
    }

    ......

protected:
    String name;
    float gamma;
};

同时还提供Drago、Reinhard、Mantiuk算法进行色调映射,大家感兴趣可以去阅读源码。

3、图像曝光源码

图像曝光的源码同样位于merge.cpp,入口是createMergeMertens(),同样使用智能指针包裹:

Ptr<MergeMertens> createMergeMertens(float wcon, float wsat, float wexp)
{
    return makePtr<MergeMertensImpl>(wcon, wsat, wexp);
}

核心源码在MergeMertensImpl类:文章来源地址https://www.toymoban.com/news/detail-479611.html

class MergeMertensImpl CV_FINAL : public MergeMertens
{
public:
    MergeMertensImpl(float _wcon, float _wsat, float _wexp) :
        name("MergeMertens"),
        wcon(_wcon),
        wsat(_wsat),
        wexp(_wexp)
    {}

    void process(InputArrayOfArrays src, OutputArray dst) CV_OVERRIDE
    {
        ......

        parallel_for_(Range(0, static_cast<int>(images.size())), [&](const Range& range) {
            for(int i = range.start; i < range.end; i++) {
                Mat img, gray, contrast, saturation, wellexp;
                std::vector<Mat> splitted(channels);

                images[i].convertTo(img, CV_32F, 1.0f/255.0f);
                if(channels == 3) {
                    cvtColor(img, gray, COLOR_RGB2GRAY);
                } else {
                    img.copyTo(gray);
                }
                images[i] = img;
                // 通道分离
                split(img, splitted);
                // 计算对比度:拉普拉斯变换
                Laplacian(gray, contrast, CV_32F);
                contrast = abs(contrast);
                // 通道求均值
                Mat mean = Mat::zeros(size, CV_32F);
                for(int c = 0; c < channels; c++) {
                    mean += splitted[c];
                }
                mean /= channels;
                // 计算饱和度
                saturation = Mat::zeros(size, CV_32F);
                for(int c = 0; c < channels;  c++) {
                    Mat deviation = splitted[c] - mean;
                    pow(deviation, 2.0f, deviation);
                    saturation += deviation;
                }
                sqrt(saturation, saturation);
                // 计算曝光量
                wellexp = Mat::ones(size, CV_32F);
                for(int c = 0; c < channels; c++) {
                    Mat expo = splitted[c] - 0.5f;
                    pow(expo, 2.0f, expo);
                    expo = -expo / 0.08f;
                    exp(expo, expo);
                    wellexp = wellexp.mul(expo);
                }

                pow(contrast, wcon, contrast);
                pow(saturation, wsat, saturation);
                pow(wellexp, wexp, wellexp);

                weights[i] = contrast;
                if(channels == 3) {
                    weights[i] = weights[i].mul(saturation);
                }
                weights[i] = weights[i].mul(wellexp) + 1e-12f;

                AutoLock lock(weight_sum_mutex);
                weight_sum += weights[i];
            }
        });

        int maxlevel = static_cast<int>(logf(static_cast<float>(min(size.width, size.height))) / logf(2.0f));
        std::vector<Mat> res_pyr(maxlevel + 1);
        std::vector<Mutex> res_pyr_mutexes(maxlevel + 1);

        parallel_for_(Range(0, static_cast<int>(images.size())), [&](const Range& range) {
            for(int i = range.start; i < range.end; i++) {
                weights[i] /= weight_sum;
                std::vector<Mat> img_pyr, weight_pyr;
                // 分别构建image、weight图像金字塔
                buildPyramid(images[i], img_pyr, maxlevel);
                buildPyramid(weights[i], weight_pyr, maxlevel);

                for(int lvl = 0; lvl < maxlevel; lvl++) {
                    Mat up;
                    pyrUp(img_pyr[lvl + 1], up, img_pyr[lvl].size());
                    img_pyr[lvl] -= up;
                }
                for(int lvl = 0; lvl <= maxlevel; lvl++) {
                    std::vector<Mat> splitted(channels);
                    // 通道分离,然后与weight权重相乘
                    split(img_pyr[lvl], splitted);
                    for(int c = 0; c < channels; c++) {
                        splitted[c] = splitted[c].mul(weight_pyr[lvl]);
                    }
                    // 图像融合
                    merge(splitted, img_pyr[lvl]);

                    AutoLock lock(res_pyr_mutexes[lvl]);
                    if(res_pyr[lvl].empty()) {
                        res_pyr[lvl] = img_pyr[lvl];
                    } else {
                        res_pyr[lvl] += img_pyr[lvl];
                    }
                }
            }
        });
        for(int lvl = maxlevel; lvl > 0; lvl--) {
            Mat up;
            pyrUp(res_pyr[lvl], up, res_pyr[lvl - 1].size());
            res_pyr[lvl - 1] += up;
        }
        dst.create(size, CV_32FCC);
        res_pyr[0].copyTo(dst);
    }

    ......

protected:
    String name;
    float wcon, wsat, wexp;
};

到了这里,关于OpenCV转换HDR图像与源码分析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • OpenCV基础操作(5)图像平滑、形态学转换、图像梯度

    1、2D卷积 我们可以对 2D 图像实施低通滤波(LPF),高通滤波(HPF)等。 LPF 帮助我们去除噪音,模糊图像。HPF 帮助我们找到图像的边缘。 OpenCV 提供的函数 cv.filter2D() 可以让我们对一幅图像进行卷积操作。 ​ ​ ​ ​ 2、图像模糊 使用低通滤波器可以达到图像模糊的目的。

    2024年02月07日
    浏览(88)
  • NumPy图像格式相互转换:使用OpenCV

    在图像处理和计算机视觉领域,NumPy和OpenCV是两个非常常用的Python库。NumPy提供了强大的多维数组操作功能,而OpenCV则提供了图像处理和计算机视觉算法的实现。在许多情况下,我们需要在这两个库之间进行图像格式的相互转换。本文将介绍如何使用OpenCV在NumPy数组和OpenCV图像

    2024年02月03日
    浏览(38)
  • opencv相机坐标到图像坐标的转换

    相机坐标到图像坐标的转换通常需要使用相机内参矩阵和外参矩阵。在OpenCV中,可以通过cv2.projectPoints()函数实现相机坐标到图像坐标的转换。具体的程序如下: 以上代码中,读取了一张图像和相机参数,使用cv2.projectPoints()函数进行相机坐标到图像坐标的转换,最后在图像上

    2024年02月11日
    浏览(43)
  • ISP-长短曝光融合生成HDR图像

    图像的动态范围是指一幅图像中量化的最大亮度与最小噪声的比值。高动态范围HDR(high dynamic range)图像,能够完整表示真实场景中跨度很大的动态范围。采用普通CMOS/CCD图像传感器不能完整呈现亮度层次差异较大的真实场景。场景中较亮的区域,由于过曝光会出现一片白亮

    2024年02月08日
    浏览(70)
  • iTOP-3568开发板使用OpenCV处理图像-颜色转换

    本小节代码在配套资料“iTOP-3568 开发板\\03_【iTOP-RK3568 开发板】指南教程 \\04_OpenCV 开发配套资料\\05”目录下,如下图所示: cv2.cvtColor()函数功能: 将一幅图像从一个色彩空间转换到另一个色彩空间。 函数原型: cv2.cvtColor(src,code,dst=None,dstCn=None) 参数定义: src:要转换的源文件

    2024年02月12日
    浏览(40)
  • 在 Python 中使用 OpenCV 通过透视校正转换图像

    在计算机视觉和图像处理领域,透视变换是一个强大的工具。它允许我们改变图像的视角以获得新的视点,通常用于校正扭曲或模拟不同的相机角度。本文将探讨一个 Python 脚本,该脚本使用计算机视觉领域流行的 OpenCV 库对图像执行透视变换。我们将详细介绍该脚本的工作原

    2024年01月25日
    浏览(47)
  • 利用OpenCV把一幅彩色图像转换成灰度图

    图像灰度化的目的是为了简化矩阵,提高运算速度。 彩色图像中的每个像素颜色由R、G、B三个分量来决定,而每个分量的取值范围都在0-255之间,这样对计算机来说,彩色图像的一个像素点就会有256*256*256=16777216种颜色的变化范围! 而灰度图像是R、G、B分量相同的一种特殊彩

    2024年02月07日
    浏览(69)
  • 【Python】【OpenCV】【NumPy】图像和原始字节的转换

    学习完基础的图像算法,开始接触OpenCV学习: 灰度图中,一个像素点上的灰度级需要一个字节(byte,2^8,8 bit)进行存储,此时的灰度图是二维的。 而当我们需要转换为彩色图时,即三维,便会产生颜色通道(Channel),这个时候,一个像素点上的灰度级便会需要三个字节来

    2024年02月05日
    浏览(35)
  • pyqt5 QImage QPixmap Opencv图像 相互转换

    只需要加上一行 QPixmap.fromImage(qimage) 即可 只需要加上一行 qimage = qpixmap.toImage() # 转为Qimage 即可

    2024年04月09日
    浏览(57)
  • Python的OpenCV模块实现图像转换素描图简单示例

    一、示例代码: 二、素描图展示: 三、高斯滤波函数说明: OpenCV 中,实现高斯滤波的函数是 cv2.GaussianBlur(),该函数的语法格式是: dst = cv2.GaussianBlur( src, ksize, sigmaX, sigmaY, borderType ) 式中: dst 是返回值,表示进行高斯滤波后得到的处理结果。 src 是需要处理的图像,即原始

    2024年01月20日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包