OpenCV实例140+ （1 图像处理基础知识）

最新推荐文章于 2021-08-03 17:39:01 发布
最新推荐文章于 2021-08-03 17:39:01 发布
阅读量460 收藏 4
点赞数 1
分类专栏： OpenCV实例140+
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43318717/article/details/100017907
版权

python + c++两个版本:
OpenCV-day-001. [图像读取与显示]

import cv2 as cv

src = cv.imread("E:/pictures/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int artc, char** argv) {
	Mat src = imread("E:/pictures/images/test.png", IMREAD_GRAYSCALE);

	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	waitKey(0);
	return 0;
}

在这里插入图片描述
OpenCV-day-002. [图像色彩空间转换]

import cv2 as cv

src = cv.imread("E:/pictures/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
cv.imshow("gray", gray)
cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int artc, char** argv) {
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	Mat gray;
	cvtColor(src, gray, COLOR_BGR2GRAY);
	imwrite("D:/gray.png", gray);
	imshow("gray", gray);

	waitKey(0);
	return 0;
}

结果相同

OpenCV-day-003. [图像对象的创建与赋值]

import cv2 as cv
import numpy as np

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)

# 克隆图像
m1 = np.copy(src)

# 赋值
m2 = src
src[100:200,200:300,:] = 255
cv.imshow("m2",m2)

m3 = np.zeros(src.shape, src.dtype)
cv.imshow("m3", m3)

m4 = np.zeros([512,512], np.uint8)
# m4[:,:] =127 try to give gray value 127
cv.imshow("m4", m4)

m5 = np.ones(shape=[512,512,3], dtype=np.uint8)
m5[:,:,0] = 255
cv.imshow("m5", m5)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int artc, char** argv) {
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", CV_WINDOW_AUTOSIZE);
	imshow("input", src);

	// 创建方法 - 克隆
	Mat m1 = src.clone();
	imshow("m1", m1);

	// 复制
	Mat m2;
	src.copyTo(m2);
	imshow("m2", m2);

	// 赋值法
	Mat m3 = src;
	imshow("m3", m3);

	// 创建空白图像
	Mat m4 = Mat::zeros(src.size(), src.type());
	imshow("m4", m4);
	Mat m5 = Mat::zeros(Size(512, 512), CV_8UC3);
	imshow("m5", m5);
	Mat m6 = Mat::ones(Size(512, 512), CV_8UC3);
	imshow("m6", m6);

	Mat kernel = (Mat_<char>(3, 3) << 0, -1, 0,
		-1, 5, -1,
		0, -1, 0);

	waitKey(0);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
OpenCV-day-004. [图像像素的读写操作]

import cv2 as cv

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
h, w, ch = src.shape
print("h , w, ch", h, w, ch)
for row in range(h):
    for col in range(w):
        b, g, r = src[row, col]
        b = 255 - b
        g = 255 - g
        r = 255 - r
        src[row, col] = [b, g, r]
cv.imshow("output", src)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int artc, char** argv) {
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", CV_WINDOW_AUTOSIZE);
	imshow("input", src);

	// 直接读取图像像素
	int height = src.rows;
	int width = src.cols;
	int ch = src.channels();
	for (int c = 0; c < ch; c++) {
		for (int row = 0; row < height; row++) {
			for (int col = 0; col < width; col++) {
				if (ch == 3) {
					Vec3b bgr = src.at<Vec3b>(row, col);
					bgr[0] = 255 - bgr[0];
					bgr[1] = 255 - bgr[1];
					bgr[2] = 255 - bgr[2];
					src.at<Vec3b>(row, col) = bgr;
				}
				else if (ch == 1) {
					int gray = src.at<uchar>(row, col);
					src.at<uchar>(row, col) = 255 - gray;
				}
			}
		}
	}
	imshow("output", src);

	// 指针读取
	Mat result = Mat::zeros(src.size(), src.type());
	int blue = 0, green = 0, red = 0;
	int gray;
	for (int c = 0; c < ch; c++) {
		for (int row = 0; row < height; row++) {
			uchar* curr_row = src.ptr<uchar>(row);
			uchar* result_row = result.ptr<uchar>(row);
			for (int col = 0; col < width; col++) {
				if (ch == 3) {
					blue = *curr_row++;
					green = *curr_row++;
					red = *curr_row++;

					*result_row++ = blue;
					*result_row++ = green;
					*result_row++ = red;
				}
				else if (ch == 1) {
					gray = *curr_row++;
					*result_row++ = gray;
				}
			}
		}
	}
	imshow("result", result);

	waitKey(0);
	return 0;
}

在这里插入图片描述
OpenCV-day-005. [图像像素的算术操作]

import cv2 as cv
import numpy as np

src1 = cv.imread("D:/vcprojects/images/LinuxLogo.jpg");
src2 = cv.imread("D:/vcprojects/images/WindowsLogo.jpg");
cv.imshow("input1", src1)
cv.imshow("input2", src2)
h, w, ch = src1.shape
print("h , w, ch", h, w, ch)

add_result = np.zeros(src1.shape, src1.dtype);
cv.add(src1, src2, add_result);
cv.imshow("add_result", add_result);

sub_result = np.zeros(src1.shape, src1.dtype);
cv.subtract(src1, src2, sub_result);
cv.imshow("sub_result", sub_result);

mul_result = np.zeros(src1.shape, src1.dtype);
cv.multiply(src1, src2, mul_result);
cv.imshow("mul_result", mul_result);

div_result = np.zeros(src1.shape, src1.dtype);
cv.divide(src1, src2, div_result);
cv.imshow("div_result", div_result);

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

 #include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int artc, char** argv) {
	Mat src1 = imread("D:/vcprojects/images/LinuxLogo.jpg");
	Mat src2 = imread("D:/vcprojects/images/WindowsLogo.jpg");
	if (src1.empty() || src2.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", CV_WINDOW_AUTOSIZE);
	imshow("input1", src1);
	imshow("input2", src2);
	int height = src1.rows;
	int width = src1.cols;

	int b1 = 0, g1 = 0, r1 = 0;
	int b2 = 0, g2 = 0, r2 = 0;
	int b = 0, g = 0, r = 0;
	Mat result = Mat::zeros(src1.size(), src1.type());
	for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
			b1 = src1.at<Vec3b>(row, col)[0];
			g1 = src1.at<Vec3b>(row, col)[1];
			r1 = src1.at<Vec3b>(row, col)[2];

			b2 = src2.at<Vec3b>(row, col)[0];
			g2 = src2.at<Vec3b>(row, col)[1];
			r2 = src2.at<Vec3b>(row, col)[2];

			result.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(b1 + b2);
			result.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(g1 + g2);
			result.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(r1 + r2);
		}
	}
	imshow("output", result);

	Mat add_result = Mat::zeros(src1.size(), src1.type());
	add(src1, src2, add_result);
	imshow("add_result", add_result);

	Mat sub_result = Mat::zeros(src1.size(), src1.type());
	subtract(src1, src2, sub_result);
	imshow("sub_result", sub_result);

	Mat mul_result = Mat::zeros(src1.size(), src1.type());
	multiply(src1, src2, mul_result);
	imshow("mul_result", mul_result);

	Mat div_result = Mat::zeros(src1.size(), src1.type());
	divide(src1, src2, div_result);
	imshow("div_result", div_result);

	waitKey(0);
	return 0;
}

在这里插入图片描述

OpenCV-day-006. [LUT的作用与用法]

import cv2 as cv

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
dst = cv.applyColorMap(src, cv.COLORMAP_COOL)
cv.imshow("output", dst)

# 伪色彩
image = cv.imread("D:/vcprojects/images/canjian.jpg")
color_image = cv.applyColorMap(image, cv.COLORMAP_JET)
cv.imshow("image", image)
cv.imshow("color_image", color_image)
cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;
void customColorMap(Mat &image);
int main(int argc, const char *argv[])
{
	Mat src = imread("D:/vcprojects/images/cos.jpg");
	if (src.empty())
	{
		printf("could not load image...\n");
		return -1;
	}
	Mat gray, dst;
	// 使用LUT
	applyColorMap(src, dst, COLORMAP_SUMMER);
	// 显示结果
	imshow("colorMap", dst);

	cvtColor(src, gray, COLOR_BGR2GRAY);
	imshow("gray", gray);
	customColorMap(gray);

	waitKey(0);
	return 0;
}

void customColorMap(Mat &image) {
	int lut[256];
	for (int i = 0; i < 256; i++) {
		if (i < 127)
			lut[i] = 0;
		else
			lut[i] = 255;
	}

	int h = image.rows;
	int w = image.cols;
	for (int row = 0; row < h; row++) {
		for (int col = 0; col < w; col++) {
			int pv = image.at<uchar>(row, col);
			image.at<uchar>(row, col) = lut[pv];
		}
	}
	imshow("lut demo", image);
}

在这里插入图片描述

OpenCV-day-007. [图像像素的逻辑操作]MJ )

import cv2 as cv
import numpy as np

# create image one
src1 = np.zeros(shape=[400, 400, 3], dtype=np.uint8)
src1[100:200, 100:200, 1] = 255
src1[100:200, 100:200, 2] = 255
cv.imshow("input1", src1)
# create image two
src2 = np.zeros(shape=[400, 400, 3], dtype=np.uint8)
src2[150:250, 150:250, 2] = 255
cv.imshow("input2", src2)

dst1 = cv.bitwise_and(src1, src2)
dst2 = cv.bitwise_xor(src1, src2)
dst3 = cv.bitwise_or(src1, src2)


cv.imshow("dst1", dst1)
cv.imshow("dst2", dst2)
cv.imshow("dst3", dst3)

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
dst = cv.bitwise_not(src)
cv.imshow("dst", dst)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, const char *argv[])
{
	// create image one
	Mat src1 = Mat::zeros(Size(400, 400), CV_8UC3);
	Rect rect(100, 100, 100, 100);
	src1(rect) = Scalar(0, 0, 255);
	imshow("input1", src1);
	printf("create first image...\n");

	// create image two
	Mat src2 = Mat::zeros(Size(400, 400), CV_8UC3);
	rect.x = 150;
	rect.y = 150;
	src2(rect) = Scalar(0, 0, 255);
	imshow("input2", src2);
	printf("create second image...\n");

	// 逻辑操作
	Mat dst1, dst2, dst3;
	bitwise_and(src1, src2, dst1);
	bitwise_xor(src1, src2, dst2);
	bitwise_or(src1, src2, dst3);

	// show results
	imshow("dst1", dst1);
	imshow("dst2", dst2);
	imshow("dst3", dst3);

	Mat src = imread("D:/vcprojects/images/test.png");
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);
	// 取反操作
	Mat dst;
	bitwise_not(src, dst);
	imshow("dst", dst);

	waitKey(0);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

OpenCV-day-008. [通道分离与合并]

import cv2 as cv

src = cv.imread("D:/vcprojects/images/flower.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)

# 蓝色通道为零
mv = cv.split(src)
mv[0][:, :] = 0
dst1 = cv.merge(mv)
cv.imshow("output1", dst1)

# 绿色通道为零
mv = cv.split(src)
mv[1][:, :] = 0
dst2 = cv.merge(mv)
cv.imshow("output2", dst2)

# 红色通道为零
mv = cv.split(src)
mv[2][:, :] = 0
dst3 = cv.merge(mv)
cv.imshow("output3", dst3)

cv.mixChannels(src, dst3, [2, 0])
cv.imshow("output4", dst3)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, const char *argv[])
{
	Mat src = imread("D:/vcprojects/images/flower.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	vector<Mat> mv;
	Mat dst1, dst2, dst3;
	// 蓝色通道为零
	split(src, mv);
	mv[0] = Scalar(0);
	merge(mv, dst1);
	imshow("output1", dst1);

	// 绿色通道为零
	split(src, mv);
	mv[1] = Scalar(0);
	merge(mv, dst2);
	imshow("output2", dst2);

	// 红色通道为零
	split(src, mv);
	mv[2] = Scalar(0);
	merge(mv, dst3);
	imshow("output3", dst3);

	waitKey(0);
	return 0;
}

在这里插入图片描述

OpenCV-day-009. [图像色彩空间转换]

import cv2 as cv

src = cv.imread("D:/vcprojects/images/lian.jpg")
cv.namedWindow("rgb", cv.WINDOW_AUTOSIZE)
cv.imshow("rgb", src)

# RGB to HSV
hsv = cv.cvtColor(src, cv.COLOR_BGR2HSV)
cv.imshow("hsv", hsv)

# RGB to YUV
yuv = cv.cvtColor(src, cv.COLOR_BGR2YUV)
cv.imshow("yuv", yuv)

# RGB to YUV
ycrcb = cv.cvtColor(src, cv.COLOR_BGR2YCrCb)
cv.imshow("ycrcb", ycrcb)

src2 = cv.imread("D:/vcprojects/images/flower.png");
cv.imshow("src2", src2)
hsv = cv.cvtColor(src2, cv.COLOR_BGR2HSV)
mask = cv.inRange(hsv, (35, 43, 46), (99, 255, 255))
cv.imshow("mask", mask)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述
在这里插入图片描述

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, const char *argv[])
{
	Mat src = imread("D:/vcprojects/images/cat.jpg");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	// RGB to HSV
	Mat hsv;
	cvtColor(src, hsv, COLOR_BGR2HSV);
	imshow("hsv", hsv);

	// RGB to YUV
	Mat yuv;
	cvtColor(src, yuv, COLOR_BGR2YUV);
	imshow("yuv", yuv);

	// RGB to YUV
	Mat ycrcb;
	cvtColor(src, ycrcb, COLOR_BGR2YCrCb);
	imshow("ycrcb", ycrcb);

	Mat src2 = imread("D:/vcprojects/images/flower.png");
	imshow("src2", src2);
	cvtColor(src2, hsv, COLOR_BGR2HSV);
	Mat mask;
	inRange(hsv, Scalar(35, 43, 46), Scalar(99, 255, 255), mask);
	imshow("mask", mask);

	waitKey(0);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

OpenCV-day-010. [图像像素值统计]

import cv2 as cv
import numpy as np

src = cv.imread("D:/vcprojects/images/test.png", cv.IMREAD_GRAYSCALE)
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)

min, max, minLoc, maxLoc = cv.minMaxLoc(src)
print("min: %.2f, max: %.2f"% (min, max))
print("min loc: ", minLoc)
print("max loc: ", maxLoc)

means, stddev = cv.meanStdDev(src)
print("mean: %.2f, stddev: %.2f"% (means, stddev))
src[np.where(src < means)] = 0
src[np.where(src > means)] = 255
cv.imshow("binary", src)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

min: 0.00, max: 255.00
min loc:  (261, 38)
max loc:  (2, 259)
mean: 158.36, stddev: 87.21

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, const char *argv[])
{
	Mat src = imread("D:/vcprojects/images/test.png", IMREAD_GRAYSCALE);
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	double minVal; double maxVal; Point minLoc; Point maxLoc;
	minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, Mat());
	printf("min: %.2f, max: %.2f \n", minVal, maxVal);
	printf("min loc: (%d, %d) \n", minLoc.x, minLoc.y);
	printf("max loc: (%d, %d)\n", maxLoc.x, maxLoc.y);

	// 彩色图像 三通道的 均值与方差
	src = imread("D:/vcprojects/images/test.png");
	Mat means, stddev;
	meanStdDev(src, means, stddev);
	printf("blue channel->> mean: %.2f, stddev: %.2f\n", means.at<double>(0, 0), stddev.at<double>(0, 0));
	printf("green channel->> mean: %.2f, stddev: %.2f\n", means.at<double>(1, 0), stddev.at<double>(1, 0));
	printf("red channel->> mean: %.2f, stddev: %.2f\n", means.at<double>(2, 0), stddev.at<double>(2, 0));


	waitKey(0);
	return 0;
}

在这里插入图片描述

min: 0.00, max: 255.00
min loc: (261, 38)
max loc: (2, 259)
blue channel->> mean: 189.64, stddev: 72.06
green channel->> mean: 154.22, stddev: 94.04
red channel->> mean: 139.90, stddev: 98.37

OpenCV-day-011. [像素归一化]

import cv2 as cv
import numpy as np

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

# 转换为浮点数类型数组
gray = np.float32(gray)
print(gray)

# scale and shift by NORM_MINMAX
dst = np.zeros(gray.shape, dtype=np.float32)
cv.normalize(gray, dst=dst, alpha=0, beta=1.0, norm_type=cv.NORM_MINMAX)
print(dst)
cv.imshow("NORM_MINMAX", np.uint8(dst*255))

# scale and shift by NORM_INF
dst = np.zeros(gray.shape, dtype=np.float32)
cv.normalize(gray, dst=dst, alpha=1.0, beta=0, norm_type=cv.NORM_INF)
print(dst)
cv.imshow("NORM_INF", np.uint8(dst*255))

# scale and shift by NORM_L1
dst = np.zeros(gray.shape, dtype=np.float32)
cv.normalize(gray, dst=dst, alpha=1.0, beta=0, norm_type=cv.NORM_L1)
print(dst)
cv.imshow("NORM_L1", np.uint8(dst*10000000))

# scale and shift by NORM_L2
dst = np.zeros(gray.shape, dtype=np.float32)
cv.normalize(gray, dst=dst, alpha=1.0, beta=0, norm_type=cv.NORM_L2)
print(dst)
cv.imshow("NORM_L2", np.uint8(dst*10000))

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

D:\ProgramData\Anaconda3\python.exe E:/PycharmProjects/test20190828/imageai.py
[[ 41.  38.  35. ...  67.  66.  68.]
 [ 38.  36.  33. ...  70.  72.  71.]
 [ 36.  32.  30. ...  70.  71.  69.]
 ...
 [152. 143. 137. ... 140. 141. 142.]
 [154. 142. 140. ... 135. 138. 134.]
 [153. 145. 147. ... 130. 132. 133.]]
[[0.16078432 0.14901961 0.13725491 ... 0.2627451  0.25882354 0.26666668]
 [0.14901961 0.14117648 0.12941177 ... 0.27450982 0.28235295 0.2784314 ]
 [0.14117648 0.1254902  0.11764707 ... 0.27450982 0.2784314  0.27058825]
 ...
 [0.59607846 0.56078434 0.5372549  ... 0.54901963 0.5529412  0.5568628 ]
 [0.6039216  0.5568628  0.54901963 ... 0.5294118  0.5411765  0.5254902 ]
 [0.6        0.5686275  0.5764706  ... 0.50980395 0.5176471  0.52156866]]
[[0.16078432 0.14901961 0.13725491 ... 0.2627451  0.25882354 0.26666668]
 [0.14901961 0.14117648 0.12941177 ... 0.27450982 0.28235295 0.2784314 ]
 [0.14117648 0.1254902  0.11764707 ... 0.27450982 0.2784314  0.27058825]
 ...
 [0.59607846 0.56078434 0.5372549  ... 0.54901963 0.5529412  0.5568628 ]
 [0.6039216  0.5568628  0.54901963 ... 0.5294118  0.5411765  0.5254902 ]
 [0.6        0.5686275  0.5764706  ... 0.50980395 0.5176471  0.52156866]]
[[1.1459725e-06 1.0621209e-06 9.7826921e-07 ... 1.8726868e-06
  1.8447362e-06 1.9006372e-06]
 [1.0621209e-06 1.0062197e-06 9.2236809e-07 ... 1.9565384e-06
  2.0124394e-06 1.9844890e-06]
 [1.0062197e-06 8.9441755e-07 8.3851648e-07 ... 1.9565384e-06
  1.9844890e-06 1.9285878e-06]
 ...
 [4.2484835e-06 3.9969286e-06 3.8292251e-06 ... 3.9130769e-06
  3.9410274e-06 3.9689780e-06]
 [4.3043847e-06 3.9689780e-06 3.9130769e-06 ... 3.7733241e-06
  3.8571757e-06 3.7453735e-06]
 [4.2764341e-06 4.0528294e-06 4.1087305e-06 ... 3.6335714e-06
  3.6894724e-06 3.7174229e-06]]
[[0.00047501 0.00044026 0.0004055  ... 0.00077624 0.00076465 0.00078783]
 [0.00044026 0.00041708 0.00038233 ... 0.000811   0.00083417 0.00082258]
 [0.00041708 0.00037074 0.00034757 ... 0.000811   0.00082258 0.00079941]
 ...
 [0.00176102 0.00165675 0.00158724 ... 0.00162199 0.00163358 0.00164516]
 [0.00178419 0.00164516 0.00162199 ... 0.00156406 0.00159882 0.00155248]
 [0.00177261 0.00167992 0.00170309 ... 0.00150614 0.00152931 0.00154089]]

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main(int argc, const char *argv[])
{
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	namedWindow("input", WINDOW_AUTOSIZE);
	imshow("input", src);

	Mat gray, gray_f;
	cvtColor(src, gray, COLOR_BGR2GRAY);

	// 转换为浮点数类型数组
	gray.convertTo(gray, CV_32F);

	// scale and shift by NORM_MINMAX
	Mat dst = Mat::zeros(gray.size(), CV_32FC1);
	normalize(gray, dst, 1.0, 0, NORM_MINMAX);
	Mat result = dst * 255;
	result.convertTo(dst, CV_8UC1);
	imshow("NORM_MINMAX", dst);

	// scale and shift by NORM_INF
	normalize(gray, dst, 1.0, 0, NORM_INF);
	result = dst * 255;
	result.convertTo(dst, CV_8UC1);
	imshow("NORM_INF", dst);

	// scale and shift by NORM_L1
	normalize(gray, dst, 1.0, 0, NORM_L1);
	result = dst * 10000000;
	result.convertTo(dst, CV_8UC1);
	imshow("NORM_L1", dst);

	// scale and shift by NORM_L2
	normalize(gray, dst, 1.0, 0, NORM_L2);
	result = dst * 10000;
	result.convertTo(dst, CV_8UC1);
	imshow("NORM_L2", dst);

	waitKey(0);
	return 0;
}

在这里插入图片描述

OpenCV-day-012. [视频文件的读写]

import cv2 as cv
import numpy as np


#capture = cv.VideoCapture("D:/vcprojects/images/768x576.avi")
capture = cv.VideoCapture(0) #打开摄像头
height = capture.get(cv.CAP_PROP_FRAME_HEIGHT)
width = capture.get(cv.CAP_PROP_FRAME_WIDTH)
count = capture.get(cv.CAP_PROP_FRAME_COUNT)
fps = capture.get(cv.CAP_PROP_FPS)
print(height, width, count, fps)
out = cv.VideoWriter("./test.mp4", cv.VideoWriter_fourcc('D', 'I', 'V', 'X'), 15,
                     (np.int(width), np.int(height)), True)
while True:
    ret, frame = capture.read()
    if ret is True:
        cv.imshow("video-input", frame)
        out.write(frame)
        c = cv.waitKey(50)
        if c == 27: # ESC
            break
    else:
        break

capture.release()
out.release()

c++1:

#include<opencv2/opencv.hpp>
#include<iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv) {
	namedWindow("camera-demo", CV_WINDOW_AUTOSIZE);
	// 打开摄像头
	VideoCapture capture(0);

	Mat frame;
	while (1) {

		capture >> frame;
		imshow("camera-demo", frame);
		char c = waitKey(50);
		if (c == 27) {
			break;
		}
		
	}
	return 0;
}

c++2:

#include<opencv2/opencv.hpp>
#include<iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv) {
	// 打开摄像头
	 //VideoCapture capture(0); 

	// 打开文件
	VideoCapture capture;
	capture.open("D:/vcprojects/images/sample.mp4");
	if (!capture.isOpened()) {
		printf("could not read this video file...\n");
		return -1;
	}
	Size S = Size((int)capture.get(CV_CAP_PROP_FRAME_WIDTH),
		(int)capture.get(CV_CAP_PROP_FRAME_HEIGHT));
	int fps = capture.get(CV_CAP_PROP_FPS);
	printf("current fps : %d \n", fps);
	VideoWriter writer("D:/test.mp4", CV_FOURCC('D', 'I', 'V', 'X'), fps, S, true);

	Mat frame;
	namedWindow("camera-demo", CV_WINDOW_AUTOSIZE);
	while (capture.read(frame)) {
		imshow("camera-demo", frame);
		writer.write(frame);
		char c = waitKey(50);
		if (c == 27) {
			break;
		}
	}
	capture.release();
	writer.release();
	waitKey(0);
	return 0;
}

OpenCV-day-013. [图像翻转]

import cv2 as cv
import numpy as np

src = cv.imread("D:/vcprojects/images/test.png")
cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
cv.imshow("input", src)

# X Flip 倒影
dst1 = cv.flip(src, 0)
cv.imshow("x-flip", dst1)

# Y Flip 镜像
dst2 = cv.flip(src, 1)
cv.imshow("y-flip", dst2)

# XY Flip 对角
dst3 = cv.flip(src, -1)
cv.imshow("xy-flip", dst3)

# custom y-flip
h, w, ch = src.shape
dst = np.zeros(src.shape, src.dtype)
for row in range(h):
    for col in range(w):
        b, g, r = src[row, col]
        dst[row, w - col - 1] = [b, g, r]
cv.imshow("custom-y-flip", dst)

cv.waitKey(0)
cv.destroyAllWindows()

在这里插入图片描述

#include<opencv2/opencv.hpp>
#include<iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv) {
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	imshow("input", src);

	Mat dst;
	// X Flip 倒影
	flip(src, dst, 0);
	imshow("x-flip", dst);

	// Y Flip 镜像
	flip(src, dst, 1);
	imshow("y-flip", dst);

	// XY Flip 对角
	flip(src, dst, -1);
	imshow("xy-flip", dst);

	waitKey(0);
	return 0;
}

在这里插入图片描述

OpenCV-day-014. [图像插值]

#include<opencv2/opencv.hpp>
#include<iostream>

using namespace cv;
using namespace std;

int main(int argc, char** argv) {
	Mat src = imread("D:/vcprojects/images/test.png");
	if (src.empty()) {
		printf("could not load image...\n");
		return -1;
	}
	imshow("input", src);

	int h = src.rows;
	int w = src.cols;
	float fx = 0.0, fy = 0.0;
	Mat dst = Mat::zeros(src.size(), src.type());
	resize(src, dst, Size(w * 1.5, h * 1.5), fx = 0, fy = 0, INTER_NEAREST);
	imshow("INTER_NEAREST", dst);

	resize(src, dst, Size(w * 1.5, h * 1.5), fx = 0, fy = 0, INTER_LINEAR);
	imshow("INTER_LINEAR", dst);

	resize(src, dst, Size(w * 1.5, h * 1.5), fx = 0, fy = 0, INTER_CUBIC);
	imshow("INTER_CUBIC", dst);

	resize(src, dst, Size(w * 1.5, h * 1.5), fx = 0, fy = 0, INTER_LANCZOS4);
	imshow("INTER_LANCZOS4", dst);

	waitKey(0);
	return 0;
}

在这里插入图片描述

OpenCV-day-015. [几何形状绘制]

OpenCV-day-016. [图像ROI与ROI操作]

大春SSC
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv 实战案例 （一）
Andrwin的博客
04-02 5335
用 Canny 算子检测图像轮廓 介绍： 使用 Canny 算子，需要指定两个阈值，基于两个阈值获得二值分布图的策略（滞后阈值化）。 在低阈值边缘分布图上值保留具有连续路径的边缘点， 同时把那些边缘点连接到属于高阈值边缘分布图的边缘上， 高阈值的边缘点被保留下来，低阈值分布图上的孤立点全部被移除。 import cv2 from PIL import Image def canny_test...
opencv实例
03-23
基于opencv的use摄像头视频采集程序 1 基于opencv的两个摄像头数据采集 3 能激发你用代码做视频的冲动程序 6 图像反转（就是把黑的变白，白的变黑） 11 图像格式的转换 12 从摄像头或者AVI文件中得到视频流，对视频流进行边缘检测 13 采用Canny算子进行边缘检测 15 角点检测 18 图像的旋转加缩放（效果很拽，用地球做就像谷歌地球似的） 21 Log-Polar极坐标变换 22 对图像进行形态学操作（图像的开闭，腐蚀和膨胀运算） 24 用不同的核进行图像的二维滤波 27 图像域的填充 30 寻找轮廓实现视频流的运动目标检测（超推荐一下） 35 采用金字塔方法进行图像分割 40 图像的亮度变换 43 单通道图像的直方图 46 计算和显示彩色图像的二维色调-饱和度图像 48 图像的直方图均匀化 50 用Hongh变换检测线段 52 利用Hough变换检测圆（是圆不是椭圆） 57 距离变换 59 椭圆曲线拟合 64 由点集序列或数组创建凸外形 68 Delaunay三角形和Voronoi划分的迭代式构造 71 利用背景建模检测运动物体（推荐） 78 运动模板检测（摄像头） 81 显示如何利用Camshift算法进行彩色目标的跟踪 86
opencv一些例子
08-27
opencv一些例子
OpenCV案例
香妃
07-12 161
opencv的使用例子
云守护的专栏
05-15 2240
显示图片的例子： #include #include using namespace std; int main() { IplImage * test; test = cvLoadImage("D:\\cvImg\\1024.jpg"); cvNamedWindow("test_demo", 1); cvShowImage("test_demo", test); cvWaitK
基于OpenCV + Python + Qt实现的图像处理仿真系统+客户端程序+源码（高分优秀项目）
最新发布
05-12
这些模块涉及到较多图像处理知识，通过每个模块设计的实例，循序渐进的让初学者加深理解图像处理方法间的联系，激发初学者对图像处理的兴趣。 软件架构：本设计利用PyCharm和QT Designer开发平台，基于Python编程...
《Opencv图像处理编程示例》pdf+代码+数据
11-27
《OpenCV图像处理编程实例》内容共三个部分，其中1～2章为基础篇，3～6章为进阶篇，7～9章为高级篇。第一部分基础篇主要介绍OpenCV开发基础的相关知识，让读者熟悉图像处理开发环境以及简单的图像处理操作；第二部分...
《从零到壹Python图像处理及识别》
03-19
第一部分是图像处理基础知识（共10章）：详细介绍了图像处理基础、OpenCV入门、几何图形绘制、算数与逻辑运算、几何变换、量化和采样处理等内容。 第二部分是图像运算和图像增强（共17章）：包括图像点运算、灰度...
《VisualC++数字图像处理技术详解》光盘代码 1-13章
02-11
　第1章　Visual C++图像处理基础 　1.1　Visual C++概述 　1.2　数字图像处理的研究内容及应用领域 　1.3　颜色模式和调色板 　1.3.1　颜色模式 　1.3.2　Windows调色板 　1.4　数字图像文件格式 　1.4.1　...
opencv 实例演示
juliarjuliar的博客
04-04 468
1. 腐蚀膨胀 main.cpp #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" //#include "highgui.h" #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; // Erosion腐蚀 Dilation膨胀 ...
OPENCV实例代码
12-16
OpenCV的全称是：Open Source Computer Vision Library。OpenCV是一个基于（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。
opencv实例源代码(近20个例子)
03-20
图像视频编码，C/C++
OpenCV实例源码
10-17
OpenCV实例源码.
opencv应用实例-实战视频教学
06-09
opencv应用实例视频教程，该课程主要分享在机器视觉及算法领域的具体应用案例，并且对这些案例的算法流程及相关接口进行详细说明与讲解，涉及到的opencv具体案例有鸟瞰图、肤色检测、颜色聚类、模板匹配、人眼检测、camshift目标跟踪、三维重建sfm。
opencv编程实例
Look Forward To
05-18 753
void ImageStitch(int index, Mat &image1, Mat &image2, const Mat &ComFrame) { static int image_source_width = 120; static int image_template_width = 100; static int image_template_heigh...
OpenCV实例总览
vine_branches的专栏
06-02 982
1.3Calibration 标定3个水平放置的相机及其相对位置，跟双目标定类似，先分别标定每个相机的内外参数，再标定第2,3相机相对第一个相机的位置，并用校正来检验标定效果 2.bagofwords_classification 用SVM训练的方法，识别单词？貌似是这个意思 3. bgfg_gmg 在光照条件会发生改变的情况下，提取背景？ 4.bgfg
基于OpenCV人脸识别案例
kuokay的博客
08-03 908
原理 我们使用机器学习的方法完成人脸检测，首先需要大量的正样本图像（面部图像）和负样本图像（不含面部的图像）来训练分类器。我们需要从其中提取特征。下图中的 Haar 特征会被使用，就像我们的卷积核，每一个特征是一 个值，这个值等于黑色矩形中的像素值之后减去白色矩形中的像素值之和。 Haar特征值反映了图像的灰度变化情况。例如：脸部的一些特征能由矩形特征简单的描述，眼睛要比脸颊颜色要深，鼻梁两侧比鼻梁颜色要深，嘴巴比周围颜色要深等。 Haar特征可用于于图像任意位置，大小也可以任意改变，所以矩形特征值是矩形
opencv实例练习
Altiumdesign的博客
02-23 150
利用鼠标画矩形或者线段 import cv2 as cv import numpy as np drawing = False # 如果 mode为true绘制矩形。按下 'm’变成绘制曲线。 默认是false 鼠标按下是true mode = True ix, iy = -1,-1 def draw_circle(event,x, y, flags, param): global ix,...
opencv示例程序
乔的博客
12-30 1033
读取图片，在窗口中显示 #include #include #include using namespace cv; int main() { // 读??入??一??张?图??片?（???游??戏??原-画-）?? Mat img=imread( "pic.jpg");
哪里可以看python图像处理实例
07-16
您可以在这些教程和课程中学习使用Python进行图像处理的基础知识和实例，例如Coursera、Udemy和网易云课堂等。 2. 图书和教材：有许多关于Python图像处理的书籍和教材可供选择。这些书籍通常包含了丰富的图像处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值