关于图像处理的OpenCV的编程案例（二）

最新推荐文章于 2024-06-27 17:26:21 发布
最新推荐文章于 2024-06-27 17:26:21 发布
阅读量1.1k 收藏 6
点赞数 1
文章标签： opencv python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55652921/article/details/120504479
版权
本文详细介绍了骰子状字块作画系统，通过大小设定、分类和赋值，以及原始图像特征值计算和映射，展示了如何将图像转化为骰子艺术。此外，涵盖了滤镜效果学习系统，包括颜色调整、艺术风格转换、光线处理和雕刻技术，如老照片、红绿互换、灰度、二值化等，并展示了实际的代码示例。
摘要由CSDN通过智能技术生成

第六章 骰子作画学习系统

6.1 骰子状字块

6.1.1 设定大小

可以根据需要，将骰子状子块大小设定为n×n个像素点的二值图像，骰子状字块内共有n×n个像素。

6.1.2 分类

可使用白色像素点个数进行分类，骰子状子块内，白色像素点的个数可能为0~n×n个，共计n×n+1种可能，即共有n×n+1种可能的骰子。

6.1.3 赋值

本系统中，骰子状子块的大小为3×3像素大小，因此其代表白色像素点的元素可能有0~9个，共计10种可能。为了处理上的方便，将具有N个值为1的像素点的骰子状子块称为N型骰子状子块。

6.2 原始图像特征值计算

将要进行骰子作画的原图像作为原始图像，将原始图像划分为n×n的互不相交的子块，计算每一个子块的和，然后将该和映射到[0，n×n]内，得到原始图像的特征值矩阵。

6.3 映射

在原始图像特征值和骰子状子块之间建立映射关系。具体的映射关系为：将原始图像特征值为N的子块与N型骰子状子块进行映射。例如，原始图像中特征值为8的子块与8型骰子状子块进行映射。

6.4 实验结果

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    int i,j;
    int X,Y;
    Y = src_img.cols;
    X = src_img.rows;
    //定义特征矩阵
    Mat Feature((X + 2) / 3, (Y + 2) / 3, CV_8UC(1), Scalar::all(0));
    //定义目标图像（骰子画）
    Mat dst_img(X, Y, CV_8UC(1), Scalar::all(0));
    Mat src_img2;
    cvtColor(src_img, src_img2, COLOR_BGR2GRAY);
    for (i = 0; i < X; i++)
        for (j = 0; j < Y; j++)
            Feature.at<uchar>(i / 3, j / 3) += src_img2.at<uchar>(i, j) / 9;
    for (i = 0; i < X / 3; i++)
        for (j = 0; j < Y / 3; j++)
            Feature.at<uchar>(i, j) /= ((255 / 9) * 9) / 9;
    //定义用来表示骰子的数组
    int T[10][3][3] = {
        //0个白点
        {0,0,0,
         0,0,0,
         0,0,0},
         //1个白点
        {0,0,0,
         0,1,0,
         0,0,0},
         //2个白点
        {1,0,0,
         0,0,0,
         0,0,1},
         //3个白点
        {1,0,0,
         0,1,0,
         0,0,1},
         //4个白点
        {1,0,1,
         0,0,0,
         1,0,1},
         //5个白点
        {1,0,1,
         0,1,0,
         1,0,1},
         //6个白点
        {1,1,1,
         0,0,0,
         1,1,1},
         //7个白点
        {1,0,1,
         1,1,1,
         1,0,1},
         //8个白点
        {1,1,1,
         1,0,1,
         1,1,1},
         //9个白点
        {1,1,1,
         1,1,1,
         1,1,1},
    };
    //映射
    for (i = 0; i < dst_img.rows; i++)
        for (j = 0; j < dst_img.cols; j++)
            dst_img.at<uchar>(i, j) = T[Feature.at<uchar>(i / 3, j / 3)][i % 3][j % 3];
    //阈值化处理
    threshold(dst_img, dst_img, 0.5, 255, THRESH_BINARY);
    imshow("骰子画", dst_img);
    waitKey();
    return 0;
}

在这里插入图片描述

第7章 滤镜效果学习系统

7.1颜色效果

7.1.1 老照片

将原始图像的RGB通道颜色进行处理以得到老照片的RGB通道，具体实现为：
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst_img(src_img.size(), CV_8UC3);
    for (int i = 1; i < src_img.rows - 1; i++)
    {
        uchar* p0 = src_img.ptr<uchar>(i);
        uchar* q0 = dst_img.ptr<uchar>(i);
        for (int j = 1; j < src_img.cols - 1; j++)
        {
            int srcR = p0[3 * j];
            int srcG = p0[3 * j + 1];
            int srcB = p0[3 * j + 2];
            int dstR, dstG, dstB;
            dstR = (101 * srcR + 197 * srcG + 48 * srcB) >> 8;
            dstG = (89 * srcR + 176 * srcG + 43 * srcB) >> 8;
            dstB = (70 * srcR + 137 * srcG + 34 * srcB) >> 8;
            dstR = dstR > 255 ? 255 : dstR;
            dstG = dstG > 255 ? 255 : dstG;
            dstB = dstB > 255 ? 255 : dstB;
            q0[3 * j] = dstR;
            q0[3 * j + 1] = dstG;
            q0[3 * j + 2] = dstB;
        }
    }
    imshow("老照片", dst_img);
    waitKey();
    return 0;
}

在这里插入图片描述

7.1.2 红绿互换

红绿互换是指红色通道与绿色通道进行交换。

cvtColor(dst_img, dst_img, COLOR_RGB2BGR);

在这里插入图片描述
此图片是老照片的红绿通道进行了交换。

7.1.3 灰度

  cvtColor(src_img, dst_img, COLOR_RGB2GRAY);

在这里插入图片描述

7.1.4 二值化

   cvtColor(src_img, dst_img, COLOR_RGB2GRAY);
   threshold(dst_img, dst_img, 128, 255, 0);

在这里插入图片描述

7.1.5 颜色变换

在这里插入图片描述

7.1.6 颜色通道

R通道：

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst[3];
    Mat dstR(src_img.rows, src_img.cols, CV_8UC1);
    split(src_img, dst);
    dst[0].copyTo(dstR);
    imshow("R通道", dstR);
    waitKey();
    return 0;
}


G通道：
在这里插入图片描述

B通道：
在这里插入图片描述

7.2 手工画

7.2.1 木雕

将图像处理为木雕效果，可以将图像的轮廓以白色显示。

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.rows,src_img.cols,CV_8UC1);
    Mat src;
    cvtColor(src_img, src, COLOR_RGB2GRAY);
    for (int i = 1; i < src.rows - 1; i++)
    {
        uchar *current = src.ptr<uchar>(i);
        uchar *currentBefore = src.ptr<uchar>(i - 1);
        uchar* currentNext = src.ptr<uchar>(i + 1);
        uchar* dstLine = dst.ptr<uchar>(i);
        for (int j = 1; j < src.cols - 1; j++)
        {
            int a, b, c, d, e, f, g, h;
            a = abs(current[j] - currentBefore[(j - 1)]);
            b = abs(current[j] - currentBefore[j]);
            c = abs(current[j] - currentBefore[(j + 1)]);
            d = abs(current[j] - currentNext[(j - 1)]);
            e = abs(current[j] - currentNext[(j)]);
            f = abs(current[j] - currentNext[(j + 1)]);
            g = abs(current[j] - current[(j - 1)]);
            h = abs(current[j] - current[(j + 1)]);
            if (a > 30 || b > 30 || c > 30 || d > 30 || e > 30 || f > 30 || g > 30 || h > 30)
                dstLine[j] = 255;
            else
                dstLine[j] = 0;
        }
    }
    imshow("木雕", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

7.2.2 铅笔画

将图像处理为铅笔画效果，可以将图像的轮廓以黑色显示。
在这里插入图片描述

7.2.3 素描

素描的处理过程为：首先将原始图像进行灰度化、反色处理得到一个图像ImgINV，再将原始图像进行高斯处理得到图像imgGauss，对上述图像进行处理如下：
在这里插入图片描述
在这里插入图片描述

7.3 艺术效果

7.3.1 连环画

连环画效果是将当前像素点的R通道、G通道、B通道分别进行算数运算后再进行灰度化。
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int y = 0; y < src_img.rows ; y++)
    {
        uchar* srcR = src_img.ptr<uchar>(y);
        uchar* dstR = dst.ptr<uchar>(y);
        int br, bg, bb;
        float brF, bgF, bbF;
        for (int x = 0; x < src_img.cols ; x++)
        {
            br = srcR[3 * x];
            bg = srcR[3 * x + 1];
            bb = srcR[3 * x + 2];
           
            brF = (abs(bg - bb + bg + br) * br) >> 8;
            bgF = (abs(bb - bg + bb + br) * br) >> 8;
            bbF = (abs(bb - bg + bb + br) * bg) >> 8;

            brF = brF > 255 ? 255 : brF;
            bgF = bgF > 255 ? 255 : bgF;
            bbF = bbF > 255 ? 255 : bbF;
            
            brF = brF < 0 ? 0 : brF;
            bgF = bgF < 0 ? 0 : bgF;
            bbF = bbF < 0 ? 0 : bbF;

            dstR[3 * x] =(uchar) brF;
            dstR[3 * x + 1] =(uchar) bgF;
            dstR[3 * x + 2] =(uchar) bbF;
        }
    }
    cvtColor(dst, dst, COLOR_BGR2GRAY);//灰度化
    normalize(dst, dst, 255, 0, NORM_MINMAX);//归一化函数
    imshow("连环画", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

7.3.2 熔铸

在这里插入图片描述

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int y = 0; y < src_img.rows ; y++)
    {
        uchar* srcR = src_img.ptr<uchar>(y);
        uchar* dstR = dst.ptr<uchar>(y);
        int br, bg, bb;
        for (int x = 0; x < src_img.cols ; x++)
        {
            br = srcR[3 * x];
            bg = srcR[3 * x + 1];
            bb = srcR[3 * x + 2];
           
            br = br * 128 / (bg + bb + 1);
            bg = bg * 128 / (br + bb + 1);
            bb = bb * 128 / (bg + br + 1);

            br = br > 255 ? 255 : br;
            bg = bg > 255 ? 255 : bg;
            bb = bb > 255 ? 255 : bb;
            
            br = br < 0 ? 0 : br;
            bg = bg < 0 ? 0 : bg;
            bb = bb < 0 ? 0 : bb;

            dstR[3 * x] = br;
            dstR[3 * x + 1] = bg;
            dstR[3 * x + 2] = bb;
        }
    }
    imshow("熔铸", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

7.3.3 冷冻

在这里插入图片描述

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int y = 0; y < src_img.rows ; y++)
    {
        uchar* srcR = src_img.ptr<uchar>(y);
        uchar* dstR = dst.ptr<uchar>(y);
        float br, bg, bb;
        for (int x = 0; x < src_img.cols ; x++)
        {
            br = srcR[3 * x];
            bg = srcR[3 * x + 1];
            bb = srcR[3 * x + 2];
           
            br = (br - bg - bb) * 3 / 2;
            bg = (bg - br - bb) * 3 / 2;
            bb = (bb - bg - br) * 3 / 2;

            br = br > 255 ? 255 : br;
            bg = bg > 255 ? 255 : bg;
            bb = bb > 255 ? 255 : bb;
            
            br = br < 0 ? -br : br;
            bg = bg < 0 ? -bg : bg;
            bb = bb < 0 ? -bb : bb;

            dstR[3 * x] =(uchar) br;
            dstR[3 * x + 1] =(uchar) bg;
            dstR[3 * x + 2] =(uchar) bb;
        }
    }
    imshow("冷冻", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

7.4 光线

7.4.1反相

反相效果的处理是用255减去当前像素点的像素值，将计算结果作为当前像素点的像素值。

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int y = 0; y < src_img.rows ; y++)
    {
        uchar* srcR = src_img.ptr<uchar>(y);
        uchar* dstR = dst.ptr<uchar>(y);
        int br, bg, bb;
        for (int x = 0; x < src_img.cols ; x++)
        {
            br = srcR[3 * x];
            bg = srcR[3 * x + 1];
            bb = srcR[3 * x + 2];
          
            dstR[3 * x] = 255 - br;
            dstR[3 * x + 1] = 255 - bg;
            dstR[3 * x + 2] = 255 - bb;
        }
    }
    imshow("反相", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

7.4.2 黑白底片

黑白底片是将图像进行反相后进行灰度化处理。
在这里插入图片描述

7.5 雕刻

7.5.1 凸雕

实现凸雕时，使用右下角的点减去左上角的点。、

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int i = 1; i < src_img.rows - 1 ; i++)
    {
        uchar* current = src_img.ptr<uchar>(i);
        uchar* currentBefore = src_img.ptr<uchar>(i-1);
        uchar* dstLine = dst.ptr<uchar>(i);
        for (int j = 1; j < src_img.cols - 1; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                int tmp0 = current[3 * j + k] - currentBefore[3 * (j - 1) + k] + 128;
                if (tmp0 < 0)
                    dstLine[3 * j + k] = 0;
                else if (tmp0 > 255)
                    dstLine[3 * j + k] = 255;
                else
                    dstLine[3 * j + k] = tmp0;
            }
        }
    }
    imshow("凸雕", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

·

7.5.2 凹雕

实现凹雕时，使用左上角的点减去右下角的点。

#include <opencv2/opencv.hpp>
#include<opencv2/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;//包含cv命名空间
int main()
{
    //读入原始图像
    Mat src_img = imread("cat1.jpg");
    imshow("原始图像", src_img);
    Mat dst(src_img.size(), CV_8UC3);
    for (int i = 1; i < src_img.rows - 1 ; i++)
    {
        uchar* current = src_img.ptr<uchar>(i);
        uchar* currentBefore = src_img.ptr<uchar>(i-1);
        uchar* dstLine = dst.ptr<uchar>(i);
        for (int j = 1; j < src_img.cols - 1; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                int tmp0 = current[3 * (j - 1) + k] - currentBefore[3 * j + k] + 128;
                if (tmp0 < 0)
                    dstLine[3 * j + k] = 0;
                else if (tmp0 > 255)
                    dstLine[3 * j + k] = 255;
                else
                    dstLine[3 * j + k] = tmp0;
            }
        }
    }
    imshow("凹雕", dst);
    waitKey();
    return 0;
}

在这里插入图片描述

哦就不多不少
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Opencv-图像处理理论与实例操作（二）
HG0724的博客
05-27 1086
2.5 图像阈值与平滑处理 2.5.1 阈值处理 实例 2.5.2. 平滑处理 平滑处理：即还是对像素点进行胡处理 均值滤波 方框滤波 normalize = True :会做归一化，即进行核大小的计算，再除去核大小 高斯滤波 距离越近越重视，发挥的效果越好；越远发挥的效果不是那么好 知识博客 图像与滤波 高斯模糊的算法 简单易懂的高斯滤波 中值滤波 中值：从小到大排序，找到中间的数值 展示所有 2.7 图像梯度 这条线左右两边都是白色一
【图像处理——OpenCV】（2）
Jnueye的博客
11-30 354
目录 1、测试代码 2、报错如下 3、报错原因 4、解决方法 1、测试代码 #include &lt;iostream&gt; #include "stdafx.h" #include &lt;opencv2/core/core.hpp&gt; #include &lt;opencv2/highgui/highgui.hpp&gt; using namespace cv; usin...
MATLAB交换图片红绿颜色通道,matlab的颜色映射colormap
weixin_34755543的博客
03-16 2525
Colormap 颜色映射1、首先说明颜色图这个概念：在matlab中用我们描述一种颜色通常用RGB(红绿蓝)的形式，当然在计算机中RGB取值都在0到1的实数，强度必须在 [0, 1] 范围内，值0表示无颜色，值1表示全强度。那么红色用[1 0 0]表示，蓝色用[0 0 1]表示，等等,那么这样的宽度是3的，包含元素为0与1之间的矩阵被称作 颜色图， 简单说颜色图就是可以为任意长度，但是宽...
【matlab 图像处理】通道互换&推向颜色模式转换&图像灰度化
weixin_52762273的博客
03-28 8665
1.蓝绿通道互换 p1 = imread('test1.jpg'); % 读取图像文件 p2 = p1; % 相当于将图像复制赋值给p2 p2(:,:,2)=p1(:,:,3); % 将p1蓝色通道赋值给p2绿色通道 1：red ; 2:green ; 3:blue p2(:,:,3)=p1(:,:,2); % 将p1绿色通道赋值给p2蓝色通道 subplot(121),imshow(p1),title('p1'); % 显示原图 subp
【OpenCV】OpenCV指南：图像处理基础及实例演示
最新发布
科技改变人类，技术成就未来
06-27 4685
OpenCV 是一个功能强大且易于使用的库，广泛应用于图像处理和计算机视觉领域。从读取和显示图像，到颜色空间转换、图像缩放、翻转、边缘检测、高斯模糊、形态学操作以及图像平滑和绘制，本文详细介绍了 OpenCV 的基础使用方法，附带了丰富的代码示例，帮助读者更直观地理解和应用。
Opencv学习1----通道交换
qq_41821444的博客
11-16 792
自己实现opencv中的通道交换函数
20个OpenCV案例，让你了解计算机视觉的广泛应用！
热门推荐
qq_28245087的博客
06-15 1万+
本文介绍了20个关于OpenCV的案例，包括人脸识别、目标检测、图像分割、光流估计、特征提取、图像拼接、图像修复、图像变换、图像配准、视频分析、三维重建、图像处理、图像识别、文字识别、图像压缩、图像增强、图像分析、图像比对、图像转换和图像特效。这些案例展示了OpenCV在计算机视觉领域的广泛应用，可以帮助读者了解OpenCV的功能和应用场景，同时也为读者提供了一些灵感和启示，可以在自己的项目中应用OpenCV进行图像处理和分析。
MATLAB基础图形处理实现图形通道转换&灰度化&旋转缩放镜像拼接
qq_58619891的博客
09-13 2143
MATLAB做基础图形处理，有注释哦，对新手友好，把jpg彩色图进行红绿通道互换，灰度化，缩放，bmp图片进行翻转镜像拼接
李立宗_OPENCV 编程案例详解.zip
06-28
Part II 进阶篇图像处理技术.. 73 第 3 章进阶篇——图像灰度变换技术. 75 3.1 阈值化处理. 76 3.1.1 OTSU 阈值化 76 3.1.2 固定阈值化 79 3.1.3 自适应阈值化.. 81 3.1.4 双阈值化. 83 3.1.5 半阈值化. 84 3.2 直方...
opencv图像处理实战案例
07-25
在本实践案例中，我们将深入探索OpenCV在Python中的应用，专注于计算机视觉和图像处理领域。OpenCV（开源计算机视觉库）是一个强大的工具，广泛用于图像和视频分析、处理以及机器学习任务。它提供了丰富的函数和算法...
OpenCV图像处理编程实例+源代码 - 副本_opencv图像_fireplace7fp_图像处理编程_图像处理_源码
10-02
"OpenCV图像处理编程实例+源代码 - 副本" 是一个资源包，提供了关于如何使用OpenCV进行图像处理的实际教程和源代码示例。在这个包中，你将找到"fireplace7fp"这样的案例，它可能是针对特定图像或场景的处理示例。 ...
数字图像处理大作业-拍照图像处理（python+OpenCV+qt）
03-27
在本项目中，我们主要探讨的是使用Python编程语言结合OpenCV和Qt库进行数字图像处理。这个大作业涵盖了多个图像处理的重要概念和技术，包括图片的文字添加、空间转换、旋转、缩放、翻转、投影矫正、二值化、图像校正...
OpenCv图像处理基础例子(C++版)
qq_57197856的博客
05-02 1697
OpenCv图像处理基础例子
opencv 实战案例 （一）
Andrwin的博客
04-02 5396
用 Canny 算子检测图像轮廓 介绍： 使用 Canny 算子，需要指定两个阈值，基于两个阈值获得二值分布图的策略（滞后阈值化）。 在低阈值边缘分布图上值保留具有连续路径的边缘点， 同时把那些边缘点连接到属于高阈值边缘分布图的边缘上， 高阈值的边缘点被保留下来，低阈值分布图上的孤立点全部被移除。 import cv2 from PIL import Image def canny_test...
深度学习02-03(图像处理、OpenCV实验案例)
yegeli的博客
07-17 4436
OpenCV实验案例 文章目录OpenCV实验案例一、OpenCV安装1. OpenCV介绍2. 安装二、OpenCV基本操作1. 图像读取与保存1）读取、图像、保存图像2. 图像色彩操作1）彩色图像转换为灰度图像2）色彩通道操作3）灰度直方图均衡化4）彩色亮度直方图均衡化5）色彩提取6）二值化与反二值化3. 图像形态操作1）图像翻转2）图像位置变换3）图像缩放4）图像裁剪5）图像相加6）图像相减7）透视变换8）图像腐蚀9）图像膨胀10）图像开运算11）图像闭运算12）形态学梯度4. 图像梯度处理1）模糊处
推荐几个Python+OpenCV实战项目
阿木寺的博客
08-12 6007
计算机视觉 (CV) 是人工智能 (AI) 的一个分支，它使计算机能够从图像、视频和其他视觉输入中提取有意义的信息。例如自动驾驶汽车、自动交通管理、监控、基于图像的质量检查等等。有不少粉丝问CVer：本人小白一枚，看了很多深度学习，机器学习以及图像处理等视频和书之后，理论有一些长进，但是实际运用能力不足，从反面也是由于理论认识不足所致，所以想问问有没有好的项目，提升下自身...
关于图像处理的OpenCV的编程案例（一）
weixin_55652921的博客
10-08 1205
1.图像处理系统 1.1 翻转 flip函数实现图像的翻转功能，其语法结构为： flip(InputArray src, OutputArray dst, int flipCode) src：要处理的原始图像。 dst：与原始图像同样大小、类型的目标图像。 flipCode：是旋转类型。 flipCode=0，沿x轴方向翻转。 flipCode为任意正数，沿y轴方向翻转。 flipCode为任意负数，x轴、y轴同时翻转。 实现代码如下： #include <opencv2/opencv.hpp>
opencv案例
qq_47434572的博客
08-27 656
切边 #include <opencv2/opencv.hpp> #include <iostream> #include <math.h> using namespace cv; using namespace std; Mat src, gray_src, dst; int threshold_value = 100; int max_level = 255; const char* output_win = "Contours Result"; const
4、opencv图像基本操作和算术运算16个应用案例
le000426的博客
10-12 1372
1、图像加法运算（用numpy） 对像素值取模(大于255的减去255用余值作为像素) 通过将数组的数值类型定义为 dtype= np.uint8,可以保证数组值的范围在[0,255] 之间 import numpy as np img1 = np.random.randint(0, 256, size=[3, 3], dtype=np.uint8)#选取0，256的随机数，组成3*3的矩阵，指定的数据类型dtype保证数值范围，自动取模 img2 = np.random.randint(0, 256, s
OpenCV图像处理实战指南
"OpenCV图像处理编程实例试读样章" ...《OpenCV图像处理编程实例》是一本全面而深入的OpenCV学习资料，它涵盖了从基础到高级的广泛主题，并通过实践案例强化了理论知识，是提升图像处理技能的理想选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值