OpenCV copyMakeBorder

已于 2023-08-12 09:47:21 修改
阅读量7.6k 收藏 16
点赞数 1
分类专栏： opencv 文章标签： OpenCV
于 2020-11-29 16:10:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiran103/article/details/110320926
版权

copyMakeBorder 将源图像复制到目标图像的中间并在图像周围形成边框。
当src已经在dst中间时，该函数不会复制src本身，而只是构造边框。在执行时函数会尝试使用 ROI 之外的像素来形成边界。若要禁用此功能并始终执行外推，就像src不是 ROI 一样，需要设置borderType | BORDER_ISOLATED。
copyMakeBorder 是 OpenCV 中较为简单的一个函数，然而由于其浅拷贝和 ROI 机制的存在，实现也并不简单。

cv::copyMakeBorder

SameSzie
Interpolate
Constant
cv::copyMakeBorder
Mat::copyTo
copyMakeBorder_8u
copyMakeConstBorder_8u
borderInterpolate

cv::copyMakeBorder 在调用时分为4种情况：

CV_INSTRUMENT_REGION() 属于 OpenCV 性能测试系统的实现工具框架。
首先 CV_Assert 检查输入参数是否合法。
CV_OCL_RUN 在第一个参数满足条件时调用 OpenCL 的实现。
_InputArray::getMat

    CV_INSTRUMENT_REGION();

    CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 && _src.dims() <= 2);

    CV_OCL_RUN(_dst.isUMat(),
               ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value))

    Mat src = _src.getMat();
    int type = src.type();

Mat::isSubmatrix 判断矩阵的属性是否为子矩阵。
Mat::locateROI 获取整个矩阵大小及子矩阵偏移。
如果源是子矩阵，并且边界格式未设置BORDER_ISOLATED，则将src向外扩。
_OutputArray::create 根据输入的类型调用相应的创建函数。后者仅在必要的情况下才开辟内存。
如果源与目的地址不一致或者步长不等则调用 Mat::copyTo。

    if( src.isSubmatrix() && (borderType & BORDER_ISOLATED) == 0 )
    {
        Size wholeSize;
        Point ofs;
        src.locateROI(wholeSize, ofs);
        int dtop = std::min(ofs.y, top);
        int dbottom = std::min(wholeSize.height - src.rows - ofs.y, bottom);
        int dleft = std::min(ofs.x, left);
        int dright = std::min(wholeSize.width - src.cols - ofs.x, right);
        src.adjustROI(dtop, dbottom, dleft, dright);
        top -= dtop;
        left -= dleft;
        bottom -= dbottom;
        right -= dright;
    }

    _dst.create( src.rows + top + bottom, src.cols + left + right, type );
    Mat dst = _dst.getMat();

    if(top == 0 && left == 0 && bottom == 0 && right == 0)
    {
        if(src.data != dst.data || src.step != dst.step)
            src.copyTo(dst);
        return;
    }

    borderType &= ~BORDER_ISOLATED;

CV_IPP_RUN_FAST 尝试调用 IPP 的实现。
如果不是常量填充则调用 copyMakeBorder_8u，否则调用 copyMakeConstBorder_8u。
scalarToRawData 将标量值赋到原始数据。

    CV_IPP_RUN_FAST(ipp_copyMakeBorder(src, dst, top, bottom, left, right, borderType, value))

    if( borderType != BORDER_CONSTANT )
        copyMakeBorder_8u( src.ptr(), src.step, src.size(),
                           dst.ptr(), dst.step, dst.size(),
                           top, left, (int)src.elemSize(), borderType );
    else
    {
        int cn = src.channels(), cn1 = cn;
        AutoBuffer<double> buf(cn);
        if( cn > 4 )
        {
            CV_Assert( value[0] == value[1] && value[0] == value[2] && value[0] == value[3] );
            cn1 = 1;
        }
        scalarToRawData(value, buf.data(), CV_MAKETYPE(src.depth(), cn1), cn);
        copyMakeConstBorder_8u( src.ptr(), src.step, src.size(),
                                dst.ptr(), dst.step, dst.size(),
                                top, left, (int)src.elemSize(), (uchar*)buf.data() );
    }

scalarToRawData

调用 scalarToRawData_ 将标量值赋到原始数据。

    CV_INSTRUMENT_REGION();

    const int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
    CV_Assert(cn <= 4);
    switch(depth)
    {
    case CV_8U:
        scalarToRawData_<uchar>(s, (uchar*)_buf, cn, unroll_to);
        break;
    case CV_8S:
        scalarToRawData_<schar>(s, (schar*)_buf, cn, unroll_to);
        break;
    case CV_16U:
        scalarToRawData_<ushort>(s, (ushort*)_buf, cn, unroll_to);
        break;
    case CV_16S:
        scalarToRawData_<short>(s, (short*)_buf, cn, unroll_to);
        break;
    case CV_32S:
        scalarToRawData_<int>(s, (int*)_buf, cn, unroll_to);
        break;
    case CV_32F:
        scalarToRawData_<float>(s, (float*)_buf, cn, unroll_to);
        break;
    case CV_64F:
        scalarToRawData_<double>(s, (double*)_buf, cn, unroll_to);
        break;
    case CV_16F:
        scalarToRawData_<float16_t>(s, (float16_t*)_buf, cn, unroll_to);
        break;
    default:
        CV_Error(CV_StsUnsupportedFormat,"");
    }

scalarToRawData_

    int i = 0;
    for(; i < cn; i++)
        buf[i] = saturate_cast<T>(s.val[i]);
    for(; i < unroll_to; i++)
        buf[i] = buf[i-cn];

copyMakeBorder_8u

检查数据指针及步长是否满足整型对齐，如果满足则按intMode执行。

    const int isz = (int)sizeof(int);
    int i, j, k, elemSize = 1;
    bool intMode = false;

    if( (cn | srcstep | dststep | (size_t)src | (size_t)dst) % isz == 0 )
    {
        cn /= isz;
        elemSize = isz;
        intMode = true;
    }

AutoBuffer 为函数的临时缓冲区。
_tab对应一行中边界元素的数量。
borderInterpolate 计算插值所用元素索引。

    cv::AutoBuffer<int> _tab((dstroi.width - srcroi.width)*cn);
    int* tab = _tab.data();
    int right = dstroi.width - srcroi.width - left;
    int bottom = dstroi.height - srcroi.height - top;

    for( i = 0; i < left; i++ )
    {
        j = cv::borderInterpolate(i - left, srcroi.width, borderType)*cn;
        for( k = 0; k < cn; k++ )
            tab[i*cn + k] = j + k;
    }

    for( i = 0; i < right; i++ )
    {
        j = cv::borderInterpolate(srcroi.width + i, srcroi.width, borderType)*cn;
        for( k = 0; k < cn; k++ )
            tab[(i+left)*cn + k] = j + k;
    }

dstInner定位到目的矩阵中与对应源矩阵原点的位置：

  • 逐行处理，如果地址不相同则拷贝；
  • 逐个拷贝左右边界元素。为什么不整体拷贝两段呢？
    srcroi.width *= cn;
    dstroi.width *= cn;
    left *= cn;
    right *= cn;

    uchar* dstInner = dst + dststep*top + left*elemSize;

    for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
    {
        if( dstInner != src )
            memcpy(dstInner, src, srcroi.width*elemSize);

        if( intMode )
        {
            const int* isrc = (int*)src;
            int* idstInner = (int*)dstInner;
            for( j = 0; j < left; j++ )
                idstInner[j - left] = isrc[tab[j]];
            for( j = 0; j < right; j++ )
                idstInner[j + srcroi.width] = isrc[tab[j + left]];
        }
        else
        {
            for( j = 0; j < left; j++ )
                dstInner[j - left] = src[tab[j]];
            for( j = 0; j < right; j++ )
                dstInner[j + srcroi.width] = src[tab[j + left]];
        }
    }

处理顶部和低部的行。

    dstroi.width *= elemSize;
    dst += dststep*top;

    for( i = 0; i < top; i++ )
    {
        j = cv::borderInterpolate(i - top, srcroi.height, borderType);
        memcpy(dst + (i - top)*dststep, dst + j*dststep, dstroi.width);
    }

    for( i = 0; i < bottom; i++ )
    {
        j = cv::borderInterpolate(i + srcroi.height, srcroi.height, borderType);
        memcpy(dst + (i + srcroi.height)*dststep, dst + j*dststep, dstroi.width);
    }

borderInterpolate

CV_TRACE_FUNCTION_VERBOSE 为追踪日志函数。
p为目的点在源矩阵坐标系上的位置，所以会有负值。len标识源矩阵的行长度。
函数内仅处理 p < 0 ∥ l e n ≤ p p < 0 \| \mathrm{len}\le p p<0∥len≤p 的情况：

  • BORDER_REPLICATE仅重复首尾元素即可；
  • BORDER_REFLECT和BORDER_REFLECT_101为镜像；
  • BORDER_WRAP为平铺效果。
    CV_TRACE_FUNCTION_VERBOSE();

    CV_DbgAssert(len > 0);

#ifdef CV_STATIC_ANALYSIS
    if(p >= 0 && p < len)
#else
    if( (unsigned)p < (unsigned)len )
#endif
        ;
    else if( borderType == BORDER_REPLICATE )
        p = p < 0 ? 0 : len - 1;
    else if( borderType == BORDER_REFLECT || borderType == BORDER_REFLECT_101 )
    {
        int delta = borderType == BORDER_REFLECT_101;
        if( len == 1 )
            return 0;
        do
        {
            if( p < 0 )
                p = -p - 1 + delta;
            else
                p = len - 1 - (p - len) - delta;
        }
#ifdef CV_STATIC_ANALYSIS
        while(p < 0 || p >= len);
#else
        while( (unsigned)p >= (unsigned)len );
#endif
    }
    else if( borderType == BORDER_WRAP )
    {
        CV_Assert(len > 0);
        if( p < 0 )
            p -= ((p-len+1)/len)*len;
        if( p >= len )
            p %= len;
    }
    else if( borderType == BORDER_CONSTANT )
        p = -1;
    else
        CV_Error( CV_StsBadArg, "Unknown/unsupported border type" );
    return p;

copyMakeConstBorder_8u

按照目的行跨度准备一个_constBuf，以value填充。

    int i, j;
    cv::AutoBuffer<uchar> _constBuf(dstroi.width*cn);
    uchar* constBuf = _constBuf.data();
    int right = dstroi.width - srcroi.width - left;
    int bottom = dstroi.height - srcroi.height - top;

    for( i = 0; i < dstroi.width; i++ )
    {
        for( j = 0; j < cn; j++ )
            constBuf[i*cn + j] = value[j];
    }

遍历源兴趣区域的每一行，如果和目的兴趣区域地址不同则复制。
左右填充，最后上下填充。

    srcroi.width *= cn;
    dstroi.width *= cn;
    left *= cn;
    right *= cn;

    uchar* dstInner = dst + dststep*top + left;

    for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
    {
        if( dstInner != src )
            memcpy( dstInner, src, srcroi.width );
        memcpy( dstInner - left, constBuf, left );
        memcpy( dstInner + srcroi.width, constBuf, right );
    }

    dst += dststep*top;

    for( i = 0; i < top; i++ )
        memcpy(dst + (i - top)*dststep, constBuf, dstroi.width);

    for( i = 0; i < bottom; i++ )
        memcpy(dst + (i + srcroi.height)*dststep, constBuf, dstroi.width);

参考资料：

图波列夫
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenCV-凸包
just_tree的博客
04-14 1942
凸包（convex hull） 概念： Graham扫描算法： API: #include <opencv2/opencv.hpp> #include <iostream> #include <math.h> #include <opencv2/highgui/highgui.hpp> using namespace std; using...
OpenCV 凸包
ccccting的博客
06-29 177
作者：ccccting 案列：© Fu Xianjun. All Rights Reserved. 什么是凸包 定义 凸包与轮廓近似相似，但不同，虽然有些情况下它们给出的结果是一样的。函数cv2.convexHull()可以用来检测一个曲线是否具有凸性缺陷，并能纠正缺陷。一般来说，凸性曲线总是凸出来的，至少是平的。如果有地方凹进去了就被叫做凸性缺陷。例如下图中的手，红色曲线显示了手的凸包，凸性缺陷被双箭头标出来了。 代码 . @param points Input 2D point s
OpenCV实现给图片添加边框功能
12-31
目标： 基于OpenCV的函数cv::copyMakeBorder给图像添加边框 函数简介： copyMakeBorder( src, dst, top, bottom, left, right, borderType, value ); 参数: src: 原图像 dst: 目标图像 top, bottom, left, right: 每一个边界方向上像素的宽度.在这里使用图像原始大小的 5% . borderType:边框的类型 。当前例子中位纯色或者边界的复制. value: 如果borderType 设置位 BORDER_CONSTANT, 这个将作为边框的颜色. 边框的类型 1）纯
OpenCV4.9中的copyMakeBorder函数的示例
03-26 613
边框是图像处理中的一项基本操作，在很多场景下需要为图像添加不同类型的边框，例如图像卷积操作时需要对图像进行扩展边界，又如在机器学习中将不同的图片统一成同一尺寸时，常会为图像添加边框。OpenCV的copyMakeBorder函数提供了一种方便快捷的方法，可以为图像增加不同类型的边框。本文将介绍如何使用copyMakeBorder函数来为图像添加不同类型的边框，以及各种边框类型的特点。
OpenCV图像处理技巧：使用cv2.copyMakeBorder()实现图像边界填充
最新发布
2301_77444219的博客
05-13 750
cv2.copyMakeBorder()是OpenCV库中的一个函数，用于给图像添加额外的边界(padding)。它的主要作用是在图像的边界上添加一些额外的像素值，以改变图像的大小或者比例，而同时保持图像的整体结构不变。
OpenCV：copyMakeBorder()-拓展边界
SSS_369
06-18 6111
1. 函数原型： void copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value = Scalar()) ​ src：输入的数组。 dst：输出的...
C++中cv::copyMakeBorder（）函数的理解和示例
不定时分享，互相学习，共同进步
10-09 1523
以cv::BORDER_CONSTANT为例进行运行展示。处理前尺寸大小为1920*1080，处理后尺寸大小为1960*1140。
Opencv中的copyMakeBorder和borderInterpolate以及getRectSubPix函数讲解
生命在于折腾！
09-06 2960
转自：http://blog.csdn.net/qianqing13579/article/details/42323397#comments 在OpenCV滤波算法中，有两个非常重要的基本工具函数，copyMakeBorder和borderInterpolate copyMakeBorder 函数原型 void copyMakeBorder( co
CopyMakeBorder函数
jerwey的博客
01-15 8760
CopyMakeBorder复制图像并且制作边界。 C++: void copyMakeBorder(InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& vlaue=Scalar()); Parameters: s...
OpenCV 扩充图像边界copyMakeBorder 函数解释
u013096791的博客
03-13 1328
--BORDER_REFLECT_101：对称法，以最边缘像素为轴，对称填充。--- BORDER_REPLICATE：复制法，复制最边缘像素，填充扩充的边界。在图像处理过程中，因为卷积算子有一定大小，所以就会导致图像一定范围的边界不能被处理，这时就需要将边界进行适当扩充。*top，bottom，left，right，分别表示在原图像的四个方向上扩充多少像素。---BORDER_REFLECT： 和对称法原理一致，不过连最边缘像素也要对称过去。*src，输入图像，即原图像，填 Mat 类的对象即可。
cv2.copyMakeBorder()函数详解
地理信息系统、摄影测量与遥感、人工智能
11-02 909
cv2.copyMakeBorder()函数详解
OpenCV-扩充图像边界cv::copyMakeBorder
翟天保的博客
06-15 3万+
函数原型：void copyMakeBorder(InputArray src, OutputArray dst,int top, int bottom, int left, int right,int borderType, const Scalar& value = Scalar() );
OpenCV-Python: cv2.copyMakeBorder()函数详解
热门推荐
要相信光
04-09 6万+
文章目录参考依据设置边界框参数实例 参考依据 OpenCV-Python官方教程：https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_core/py_basic_ops/py_basic_ops.html 设置边界框 如果你想给你的图片设置边界框，就像一个相框一样的东西，你就可以使用cv2.copyMake...
python opencv 图像边框(填充)添加及图像混合的实现方法（末尾实现类似幻灯片渐变的效果）
01-20
cv.copyMakeBorder()——实现边框填充 主要参数如下： 参数一：源图像——如：读取的img 参数二——参数五分别是：上下左右边的宽度——单位：像素 参数六：边框类型： cv.BORDER_CONSTANT——cv.BORDER_...
OpenCV入门教程
04-03
2. 图像处理：包括图像的裁剪、旋转、缩放、色彩空间转换（如BGR到灰度或HSV），这些操作通过相应函数实现，如`cv2.copyMakeBorder()`、`cv2.rotate()`、`cv2.resize()`、`cv2.cvtColor()`。 三、OpenCV中的滤波与...
opencv3.3.0.js
11-26
3. 基本图像操作：缩放、裁剪、旋转，`cv.resize()`, `cv.copyMakeBorder()`, `cv.getRotationMatrix2D()`等 4. 图像滤波：均值滤波、高斯滤波、中值滤波，`cv.blur()`, `cv.GaussianBlur()`, `cv.medianBlur()` 5. ...
OpenCV函数手册
06-03
2. 图像基本操作：`cv2.resize()`进行图像缩放，`cv2.rotate()`实现图像旋转，`cv2.copyMakeBorder()`添加图像边框，`cv2.threshold()`进行二值化处理。 三、颜色空间转换 OpenCV支持多种颜色空间之间的转换，如BGR...
Opencv实现傅里叶变换
08-27
copyMakeBorder(srcImage, padded, 0, m - srcImage.rows, 0, n - srcImage.cols, BORDER_CONSTANT, Scalar::all(0)); // 3. 为傅里叶变换的结果（实部和虚部）分配存储空间 Mat planes[] = { Mat_(padded), Mat...
opencv-python | cv2.copyMakeBorder使用方法与注意事项
Just_do_myself的博客
07-08 4225
在图像处理任务中，我们经常会使用到改变图像尺寸的操作，比较常见的有Resize、裁剪等。除此之外，还有一种操作是扩充图像的边界，比如在图像的左右或者上下添加若干列(行)的像素。在openCV中，通过函数cv2.copyMakeBorder()完成此操作。openCV官方文档对cv2.copyMakeBorder()的作用介绍就是给你的图像添加额外的边界（padding）。比如，当我们在进行卷积操作的时候，一个很自然的问题就是：如何处理图像的边界？怎么对图像边界的点进行卷积？是的，可以通过扩充边界(Paddi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值