opencv常用图像处理函数详解(二)

已于 2023-02-08 11:02:23 修改
阅读量466 收藏 3
点赞数
分类专栏： opencv 文章标签： opencv 图像处理 计算机视觉
于 2022-12-15 07:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30150579/article/details/128306812
版权

文章目录

1.在图像上绘制几何形状

  1. 绘制线段

    void cv::line(	InputOutputArray img,
				Point pt1,
				Point pt2,
				const Scalar & 	color,
				int thickness = 1,
				int lineType = LINE_8,
				int shift = 0 
)		

    cv.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) ->img

    说明：在图像上绘制连接两点的线段
参数：
	img	图像.
	pt1	线段的起点.
	pt2	线段的终点.
	color 线段的颜色.
	thickness 线段的粗细
	lineType 线段的线型.
	shift 点坐标中的小数位数.

  2. 绘制椭圆

    void cv::ellipse(	InputOutputArray img,
					Point center,
					Size axes,
					double angle,
					double startAngle,
					double endAngle,
					const Scalar & color,
					int thickness = 1,
					int lineType = LINE_8,
					int shift = 0 
)	 

    cv.ellipse(	img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]	) ->img
cv.ellipse(	img, box, color[, thickness[, lineType]]) ->img

    说明：绘制简单或粗椭圆弧或填充椭圆扇区
参数：
	img	图像.
	center 椭圆的中点.
	axes 椭圆主轴尺寸的一半.
	angle 椭圆旋转角度（度）.
	startAngle 椭圆弧的起始角度（度）
	endAngle 椭圆弧的终止角度（度）.
	color 椭圆弧的颜色.
	thickness 线段的粗细
	lineType 线段的线型.
	shift 点坐标中的小数位数.

在这里插入图片描述

  1. 绘制矩形

    void cv::rectangle(	InputOutputArray img,
					Point pt1,
					Point pt2,
					const Scalar & 	color,
					int thickness = 1,
					int lineType = LINE_8,
					int shift = 0 
)		

    cv.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) ->img

    说明：在图像上绘制矩形
参数：
	img	图像.
	pt1	矩形的左上角坐标点.
	pt2	矩形的右下角坐标点.
	color 线段的颜色.
	thickness 线段的粗细
	lineType 线段的线型.
	shift 点坐标中的小数位数.

  2. 绘制圆

    void cv::circle(	InputOutputArray img,
					Point center,
					int radius,
					const Scalar & 	color,
					int thickness = 1,
					int lineType = LINE_8,
					int shift = 0 
)		

    cv.circle(img, center, radius, color[, thickness[, lineType[, shift]]]) ->img

    说明：在图像上绘制圆
参数：
	img	图像.
	pt1	圆形的中心点.
	radius	圆形的半径.
	color 线段的颜色.
	thickness 线段的粗细
	lineType 线段的线型.
	shift 点坐标中的小数位数.

  3. 绘制多边形

    void cv::fillPoly(	InputOutputArray img,
					InputArrayOfArrays pts,
					const Scalar & 	color,
					int thickness = 1,
					int lineType = LINE_8,
					Point offset = Point() 
)		

    cv.fillPoly(img, pts, color[, lineType[, shift[, offset]]]) ->img

    说明：在图像上绘制圆
参数：
	img	图像.
	pts	多边形阵列，其中每个多边形表示为点阵列.
	color 线段的颜色.
	thickness 线段的粗细
	lineType 线段的线型.
	offset 偏移量.

例程:

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>

#define w 400 //定义图像的大小
using namespace cv;

void MyEllipse( Mat img, double angle );
void MyFilledCircle( Mat img, Point center );
void MyPolygon( Mat img );
void MyLine( Mat img, Point start, Point end );

int main( void ){
  //定义两个窗口的名称，用来显示绘制好的图像
  char atom_window[] = "Drawing 1: Atom";
  char rook_window[] = "Drawing 2: Rook";

  //绘制图像的矩阵
  Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
  Mat rook_image = Mat::zeros( w, w, CV_8UC3 );

  //绘制多个椭圆
  MyEllipse( atom_image, 90 );
  MyEllipse( atom_image, 0 );
  MyEllipse( atom_image, 45 );
  MyEllipse( atom_image, -45 );

  //绘制圆
  MyFilledCircle( atom_image, Point( w/2, w/2) );

  //绘制多边形
  MyPolygon( rook_image );
	
  //绘制矩形
  rectangle( rook_image, Point( 0, 7*w/8 ), Point( w, w), Scalar( 0, 255, 255 ), FILLED, LINE_8 );
  
  //绘制直线
  MyLine( rook_image, Point( 0, 15*w/16 ), Point( w, 15*w/16 ) );
  MyLine( rook_image, Point( w/4, 7*w/8 ), Point( w/4, w ) );
  MyLine( rook_image, Point( w/2, 7*w/8 ), Point( w/2, w ) );
  MyLine( rook_image, Point( 3*w/4, 7*w/8 ), Point( 3*w/4, w ) );

  //显示图像
  imshow( atom_window, atom_image );
  moveWindow( atom_window, 0, 200 );
  imshow( rook_window, rook_image );
  moveWindow( rook_window, w, 200 );
  waitKey( 0 );
  return(0);
}

void MyEllipse( Mat img, double angle )
{
  int thickness = 2;
  int lineType = 8;
  ellipse( img, Point( w/2, w/2 ), Size( w/4, w/16 ), angle, 0, 360, Scalar( 255, 0, 0 ), thickness, lineType );
}

void MyFilledCircle( Mat img, Point center )
{
  circle( img, center, w/32, Scalar( 0, 0, 255 ), FILLED, LINE_8 );
}

void MyPolygon( Mat img )
{
  int lineType = LINE_8;
  Point rook_points[1][20];
  rook_points[0][0]  = Point(    w/4,   7*w/8 );
  rook_points[0][1]  = Point(  3*w/4,   7*w/8 );
  rook_points[0][2]  = Point(  3*w/4,  13*w/16 );
  rook_points[0][3]  = Point( 11*w/16, 13*w/16 );
  rook_points[0][4]  = Point( 19*w/32,  3*w/8 );
  rook_points[0][5]  = Point(  3*w/4,   3*w/8 );
  rook_points[0][6]  = Point(  3*w/4,     w/8 );
  rook_points[0][7]  = Point( 26*w/40,    w/8 );
  rook_points[0][8]  = Point( 26*w/40,    w/4 );
  rook_points[0][9]  = Point( 22*w/40,    w/4 );
  rook_points[0][10] = Point( 22*w/40,    w/8 );
  rook_points[0][11] = Point( 18*w/40,    w/8 );
  rook_points[0][12] = Point( 18*w/40,    w/4 );
  rook_points[0][13] = Point( 14*w/40,    w/4 );
  rook_points[0][14] = Point( 14*w/40,    w/8 );
  rook_points[0][15] = Point(    w/4,     w/8 );
  rook_points[0][16] = Point(    w/4,   3*w/8 );
  rook_points[0][17] = Point( 13*w/32,  3*w/8 );
  rook_points[0][18] = Point(  5*w/16, 13*w/16 );
  rook_points[0][19] = Point(    w/4,  13*w/16 );
  const Point* ppt[1] = { rook_points[0] };
  int npt[] = { 20 };
  fillPoly( img, ppt, npt, 1, Scalar( 255, 255, 255 ), lineType );
}

void MyLine( Mat img, Point start, Point end )
{
  int thickness = 2;
  int lineType = LINE_8;
  line( img, start, end, Scalar( 0, 0, 0 ), thickness, lineType );
}

在这里插入图片描述

2.在图像上写文字

例程:

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <stdio.h>

using namespace cv;

//全局变量
const int NUMBER = 8; //每个图形绘制的次数
const int DELAY = 5; //每次绘制图形后等待的时间ms

const int window_width = 900;
const int window_height = 600;
int x_1 = -window_width/2;
int x_2 = window_width*3/2;
int y_1 = -window_width/2;
int y_2 = window_width*3/2;

//函数声明
static Scalar randomColor( RNG& rng );
int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
int Displaying_Big_End( Mat image, char* window_name, RNG rng );


/**
 * @function main
 */
int main( void )
{
  int c; // 用于显示错误代码的int变量

  //窗口名称，用于命名后续显示图像用的窗口
  char window_name[] = "Drawing_2 Tutorial";

  //创建一个随机数生成对象
  RNG rng( 0xFFFFFFFF );

  //创建一个以0填充的图像(黑色图像)
  Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );

  //将图像显示在窗口上
  imshow( window_name, image );
  waitKey( DELAY );

  //第一步，先随机画几条线
  c = Drawing_Random_Lines(image, window_name, rng);
  if( c != 0 ) return 0;

  //第二步，绘制矩形
  c = Drawing_Random_Rectangles(image, window_name, rng);
  if( c != 0 ) return 0;

  //第三步，绘制椭圆
  c = Drawing_Random_Ellipses( image, window_name, rng );
  if( c != 0 ) return 0;

  //第四步，绘制多边形
  c = Drawing_Random_Polylines( image, window_name, rng );
  if( c != 0 ) return 0;

  //第五步，绘制填充的多边形
  c = Drawing_Random_Filled_Polygons( image, window_name, rng );
  if( c != 0 ) return 0;

  //第六步，绘制圆
  c = Drawing_Random_Circles( image, window_name, rng );
  if( c != 0 ) return 0;

  //第七步，绘制文字
  c = Displaying_Random_Text( image, window_name, rng );
  if( c != 0 ) return 0;

  //第八步，显示最终的文字
  c = Displaying_Big_End( image, window_name, rng );
  if( c != 0 ) return 0;

  waitKey(0);
  return 0;
}

/// Function definitions

/**
 * @function randomColor
 * @brief 从随机数中生成随机颜色
 */
static Scalar randomColor( RNG& rng )
{
  int icolor = (unsigned) rng;
  return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
}


/**
 * @function Drawing_Random_Lines
 * @brief 在图像上画出随机线条
 */
int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
{
  Point pt1, pt2;

  for( int i = 0; i < NUMBER; i++ )
  {
    pt1.x = rng.uniform( x_1, x_2 );
    pt1.y = rng.uniform( y_1, y_2 );
    pt2.x = rng.uniform( x_1, x_2 );
    pt2.y = rng.uniform( y_1, y_2 );

    line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
    imshow( window_name, image );
    if( waitKey( DELAY ) >= 0 )
      { return -1; }
  }

  return 0;
}

/**
 * @function Drawing_Rectangles
 * @brief 在图像上画出随机矩形
 */
int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
{
  Point pt1, pt2;
  int lineType = 8;
  int thickness = rng.uniform( -3, 10 );

  for( int i = 0; i < NUMBER; i++ )
  {
    pt1.x = rng.uniform( x_1, x_2 );
    pt1.y = rng.uniform( y_1, y_2 );
    pt2.x = rng.uniform( x_1, x_2 );
    pt2.y = rng.uniform( y_1, y_2 );

    rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );

    imshow( window_name, image );
    if( waitKey( DELAY ) >= 0 )
      { return -1; }
  }

  return 0;
}

/**
 * @function Drawing_Random_Ellipses
 * @brief 在图像上画出随机椭圆
 */
int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
{
  int lineType = 8;

  for ( int i = 0; i < NUMBER; i++ )
  {
    Point center;
    center.x = rng.uniform(x_1, x_2);
    center.y = rng.uniform(y_1, y_2);

    Size axes;
    axes.width = rng.uniform(0, 200);
    axes.height = rng.uniform(0, 200);

    double angle = rng.uniform(0, 180);

    ellipse( image, center, axes, angle, angle - 100, angle + 200,
             randomColor(rng), rng.uniform(-1,9), lineType );

    imshow( window_name, image );
    if( waitKey(DELAY) >= 0 )
      { return -1; }
  }

  return 0;
}

/**
 * @function Drawing_Random_Polylines
 * @brief 在图像上画出随机多边形
 */
int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
{
  int lineType = 8;

  for( int i = 0; i< NUMBER; i++ )
  {
    Point pt[2][3];
    pt[0][0].x = rng.uniform(x_1, x_2);
    pt[0][0].y = rng.uniform(y_1, y_2);
    pt[0][1].x = rng.uniform(x_1, x_2);
    pt[0][1].y = rng.uniform(y_1, y_2);
    pt[0][2].x = rng.uniform(x_1, x_2);
    pt[0][2].y = rng.uniform(y_1, y_2);
    pt[1][0].x = rng.uniform(x_1, x_2);
    pt[1][0].y = rng.uniform(y_1, y_2);
    pt[1][1].x = rng.uniform(x_1, x_2);
    pt[1][1].y = rng.uniform(y_1, y_2);
    pt[1][2].x = rng.uniform(x_1, x_2);
    pt[1][2].y = rng.uniform(y_1, y_2);

    const Point* ppt[2] = {pt[0], pt[1]};
    int npt[] = {3, 3};

    polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);

    imshow( window_name, image );
    if( waitKey(DELAY) >= 0 )
      { return -1; }
  }
  return 0;
}

/**
 * @function Drawing_Random_Filled_Polygons
 * @brief 在图像上画出随机填充多边形
 */
int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
{
  int lineType = 8;

  for ( int i = 0; i < NUMBER; i++ )
  {
    Point pt[2][3];
    pt[0][0].x = rng.uniform(x_1, x_2);
    pt[0][0].y = rng.uniform(y_1, y_2);
    pt[0][1].x = rng.uniform(x_1, x_2);
    pt[0][1].y = rng.uniform(y_1, y_2);
    pt[0][2].x = rng.uniform(x_1, x_2);
    pt[0][2].y = rng.uniform(y_1, y_2);
    pt[1][0].x = rng.uniform(x_1, x_2);
    pt[1][0].y = rng.uniform(y_1, y_2);
    pt[1][1].x = rng.uniform(x_1, x_2);
    pt[1][1].y = rng.uniform(y_1, y_2);
    pt[1][2].x = rng.uniform(x_1, x_2);
    pt[1][2].y = rng.uniform(y_1, y_2);

    const Point* ppt[2] = {pt[0], pt[1]};
    int npt[] = {3, 3};

    fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );

    imshow( window_name, image );
    if( waitKey(DELAY) >= 0 )
       { return -1; }
  }
  return 0;
}

/**
 * @function Drawing_Random_Circles
 * @brief 在图像上画出随机圆
 */
int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
{
  int lineType = 8;

  for (int i = 0; i < NUMBER; i++)
  {
    Point center;
    center.x = rng.uniform(x_1, x_2);
    center.y = rng.uniform(y_1, y_2);

    circle( image, center, rng.uniform(0, 300), randomColor(rng),
            rng.uniform(-1, 9), lineType );

    imshow( window_name, image );
    if( waitKey(DELAY) >= 0 )
      { return -1; }
  }

  return 0;
}

/**
 * @function Displaying_Random_Text
 * @brief 在图像上画出随机打印出字
 */
int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
{
  int lineType = 8;

  for ( int i = 1; i < NUMBER; i++ )
  {
    Point org;
    org.x = rng.uniform(x_1, x_2);
    org.y = rng.uniform(y_1, y_2);

    putText( image, "Testing text rendering", org, rng.uniform(0,8),
             rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);

    imshow( window_name, image );
    if( waitKey(DELAY) >= 0 )
      { return -1; }
  }

  return 0;
}

/**
 * @function Displaying_Big_End
 */
int Displaying_Big_End( Mat image, char* window_name, RNG )
{
  Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
  Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
  int lineType = 8;

  Mat image2;

  for( int i = 0; i < 255; i += 10 )
  {
    image2 = image - Scalar::all(i);
    putText( image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
             Scalar(i, i, 255), 5, lineType );

    imshow( window_name, image2 );
    if( waitKey(DELAY) >= 0 )
       { return -1; }
  }

  return 0;
}
AoDeLuo
关注
专栏目录
OpenCV-Python实战（1）——OpenCV简介与图像处理基础
盼小辉丶的博客
08-10 22万+
OpenCV 是一个的跨平台计算机视觉库，可以运行在 Linux、Windows 和 Mac OS 操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时也提供了 Python 接口，实现了图像处理和计算机视觉方面的很多通用算法。在本文中，将介绍 OpenCV 库，包括它的主要模块和典型应用场景，同时使用 OpenCV-Python 实战讲解图像处理基础要点。
OpenCV实战（1）——OpenCV与图像处理基础
热门推荐
盼小辉丶的博客
10-24 6万+
OpenCV 是一个跨平台计算机视觉和机器学习库，实现了图像处理和计算机视觉方面的很多通用算法。本节将介绍 OpenCV 的基础知识，以及如何编译运行 OpenCV 程序，并介绍如何完成最基本的图像处理任务——读取、显示和保存图像。除此之外，鼠标事件和图形绘制也是 OpenCV 计算机视觉项目中常用的基本功能，本节介绍了如何使用这两个重要的 OpenCV 功能。
opencv图像处理中常用函数汇总
04-25
opencv图像处理中常用函数汇总，包括显示图像，保存图像，图像灰度化，边缘检测等函数使用方式
OpenCV图像处理中常用函数汇总（1）
weixin_34362991的博客
07-20 247
1 //俗话说：好记性不如烂笔头 2 //用到opencv 中的函数时往往会一时记不起这个函数的具体参数怎么设置，故在此将常用函数做一汇总； 3 4 Mat srcImage = imread("C:/Users/Administrator/Desktop/车牌识别/车牌图像库/1.jpg");//读入图像函数 5 6 imshow("原图",srcImage);...
opencv 常用函数总结
最新发布
weixin_44063529的博客
07-27 632
本文是一份OpenCV图像处理的常用函数总结，详细介绍了图像的读入、显示、保存、像素处理、图像属性获取、基础操作、阈值处理、图像平滑、形态学转换以及直方图处理等关键技术。文章通过代码示例和参数说明，帮助读者快速掌握OpenCV在图像处理领域的应用。
OpenCV 图像处理常用函数（转）
彼岸花
03-07 1054
OpenCV 图像处理常用函数[转载zdd_19191的博客] 2007-03-18 19:49 http://hi.baidu.com/zhongdudu/blog/item/8f6b242424e53833c995597f.html 关于Opencv的一些内容, 可以访问该博客的其他内容. OpenCV 图像处理常用函数 2007-02-25 12
opencv图像处理常用函数
jacke121的专栏
02-05 1831
opencv图像处理常用函数
关于OpenCV的一些图像处理函数
Chaoy6565的博客
01-21 901
图像阈值src： 输入图，只能输入单通道图像，通常来说为灰度图dst： 输出图thresh： 阈值maxval： 当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值type：二值化操作的类型，包含以下5种类型： cv2.THRESH_BINARY；cv2.THRESH_BINARY 超过阈值部分取maxval（最大值），否则取0cv2.THRESH_BINARY_INV THRESH_BINARY的反转。
opencv处理函数，图像处理常用函数
weixin_42049458的博客
03-26 654
由于众所周知的原因，OpenCv官网我们常常404，笔者这里直接整理了中文版的opencv graph API函数，也是我们图像处理过程中常用的函数，若你可链接外网可直接查看opencv graph API 其中存在少许的乱码可能笔者未能检查出，凑合着学把。 功能 详细说明 本节中描述的函数和类用于对2D图像（表示为Mat）执行各种线性或非线性滤波操作。这意味着对于源图像（通常为矩形）中的每个像素...
OpenCv入门（二）-图像处理基本函数
cow_boy001的专栏
12-12 2361
图像处理 1、图像的内存分配与释放 （1） 分配内存给一幅新图像: IplImage* cvCreateImage(CvSize size, int depth, int channels);   size: cvSize(width,height); depth: 像素深度: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U,    IPL
opencv 常用函数详解
07-21
以下是对OpenCV常用函数的详细讲解： 1. **cv::imread()**: 用于读取图像文件，接受文件路径和读取模式作为参数。读取模式包括IMREAD_COLOR（默认，彩色图像），IMREAD_GRAYSCALE（灰度图像），IMREAD_UNCHANGED...
opencv图像处理工具集
04-05
**OpenCV 图像处理工具集详解** OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供了丰富的函数和模块，用于处理图像和视频数据。这个工具集集成了多种功能，包括相机标定、角点检测...
OpenCV各模块、函数详解及应用案例
学以致用 知行合一
06-11 1380
OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和机器学习软件库。OpenCV库拥有超过 2500 种优化算法，其中包括一整套经典和最先进的计算机视觉和机器学习算法。 OpenCV主要分几个大模块：（1）核心功能，主要是Mat容器以及基本操作等。（2）图像处理模块。（3）GUI和视频处理等模块。（4）相机校准和 3D 重建（5）2D 特征框架（feature2d 模块） - 特征检测器、描述符和匹配框架...............
OpenCV图像处理--常用的一些函数
君莫笑的博客
10-15 1045
Mat matBinary, matGray, matOut; //读图 show图 Mat inMat = imread(“pic.bmp”, -1); //读进原图 //Mat inMat = imread(“pic.bmp”, 0) //将原图转为单通道灰度图在读进 //Mat inMat = imread(“pic.bmp”, 1) //将原图转为三通道RGB图在读进 imshow(“winname”, inMat); //show出inMat //腐蚀 膨胀 Mat element = getSt
OpenCV学习笔记-Sobel算子
yingyingol
08-05 277
该函数如下： Sobel 使用扩展 Sobel 算子计算一阶、二阶、三阶或混合图像差分 void cvSobel( const CvArr* src, CvArr* dst, int xorder, int yorder, int aperture_size=3 ); src 输入图像. dst 输出图像. xorder x 方向上的差分阶数 yorder y 方向上的差分阶数 apertu...
opencv 图像处理函数大全
weixin_30312563的博客
08-31 155
1、cvLoadImage：将图像文件加载至内存； 2、cvNamedWindow：在屏幕上创建一个窗口； 3、cvShowImage：在一个已创建好的窗口中显示图像； 4、cvWaitKey：使程序暂停，等待用户触发一个按键操作； 5、cvReleaseImage：释放图像文件所分配的内存； 6、cvDestroyWindow：销毁显示图像文件的窗口...
【图像处理】——opencv常用函数
python_AI_fans的博客
07-02 483
目录 读取图像 显示图像 等待键盘输入 销毁窗口 保存一张图像 图像复制 图像颜色空间转换（灰彩互转） 图像缩放 图像旋转 图像放射变换 图像添加文字 在图像上绘制矩形 图像的四值属性 读取图像 cv2.imread(filepath,flags) #读入一张图像 filepath：要读入图片的完整路径 flags：读入图片的标志 cv2.IMREAD_COLOR：默认参数，读入一副彩色图片，忽略alpha通道 cv2....
基本的opencv图像处理函数
宁静致远的博客
05-13 908
原文地址：基本的opencv图像处理函数作者：宁静致远lsp155.cvCanny：Canny边缘检测； 156.cvSobel：图像边缘检测，Sobel算子； 157.cvLaplace：拉普拉斯变换、图像边缘检测； 150.cvThreshold：图像阈值化； 178.cvEqualizeHist：直方图均衡化； 179.cvCreateHist：创建一新直方图； 180.cvReleaseH
OpenCV图像处理常用函数详解
以下是一些重要的OpenCV图像处理函数及其用途： 1. 读取和显示图像 - `imread()`：用于从指定路径读取图像，并返回一个`Mat`对象，如`Mat srcImage = imread("path/to/image.jpg")`。 - `imshow()`：显示图像，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AoDeLuo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值