图像处理（七）：图像变换

最新推荐文章于 2025-02-15 16:52:47 发布
原创 最新推荐文章于 2025-02-15 16:52:47 发布 · 763 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++ #图像处理 平移镜像 #旋转

图像的平移、镜像原理都很简单，一搜一大堆。

具体可以参考博客：点击打开链接

实现代码如下：

#include <opencv2/opencv.hpp>

using namespace cv;

int main()
{
	Mat src = imread("1.jpg");
	Mat gray;
	cvtColor(src, gray, CV_BGR2GRAY);

	//1、 平移变换
	int Xoffset = 30, Yoffset = 50;
	Mat Moved_img = Mat::zeros(gray.rows + Xoffset, gray.cols + Yoffset, CV_8UC1);
	int i, j;
	for (i = Xoffset; i < Moved_img.rows; i++)
		for (j = Yoffset; j < Moved_img.cols; j++)
		{
			Moved_img.at<uchar>(i, j) = gray.at<uchar>(i - Xoffset , j - Yoffset);
		}

	// 2、镜像
	// 2.1、水平镜像
	Mat Rotated_x = Mat::zeros(gray.rows, gray.cols, CV_8UC1);
	Mat Rotated_y = Mat::zeros(gray.rows, gray.cols, CV_8UC1);
	int c = 0;
	// 计算对称中心
	if (gray.cols % 2 ==  0)
	{
		c = gray.cols / 2;
	}
	else
	{
		c = gray.cols / 2 + 1;
	}

	for (i = 0; i < gray.rows; i++)
		for (j = 0; j < c; j++)
		{
			Rotated_x.at<uchar>(i, j) = gray.at<uchar>(i, gray.cols - 1 - j);
			Rotated_x.at<uchar>(i, gray.cols - 1 - j) = gray.at<uchar>(i, j);
		}

	// 2.2、垂直方向
	// 计算对称中心
	c = 0;
	if (gray.rows % 2 == 0)
	{
		c = gray.rows / 2;
	}
	else
	{
		c = gray.rows / 2 + 1;
	}

	for (i = 0; i < c; i++)
		for (j = 0; j < gray.cols; j++)
		{
			Rotated_y.at<uchar>(i, j) = gray.at<uchar>(gray.rows - 1 - i, j);
			Rotated_y.at<uchar>(gray.rows - 1 - i, j) = gray.at<uchar>(i, j);
		}
	namedWindow("gray", 0);
	resizeWindow("gray", 300, 300);

	namedWindow("Moved_img", 0);
	resizeWindow("Moved_img", 300, 300);

	namedWindow("Rotated_x", 0);
	resizeWindow("Rotated_x", 300, 300);

	namedWindow("Rotated_y", 0);
	resizeWindow("Rotated_y", 300, 300);

	imshow("gray", gray);
	imshow("Moved_img", Moved_img);
	imshow("Rotated_x", Rotated_x);
	imshow("Rotated_y", Rotated_y);

	waitKey();

	return 0;


}
效果如下：


图像旋转原理，可以参考JoStudio的博客：点击打开链接，他的这个系列博客，使用opencv实现photoshop系列博客真心不错，有兴趣的可以follow一下，代码如下：

#include <opencv2/opencv.hpp>
#include <math.h>

using namespace cv;
using namespace std;

int main()
{
	Mat src = imread("1.jpg");
	float angle = 30 * CV_PI / 180;

	int new_R = ceil(abs(src.cols * cos(angle)) + abs(src.rows * sin(angle)));
	int new_C = ceil(abs(src.cols * sin(angle)) + abs(src.rows * cos(angle)));

	Mat Rotated_img = Mat::zeros(new_R, new_C, CV_8UC3);

	// 旋转
	// 1、旋转中心
	Point C = Point(src.rows / 2, src.cols / 2);  // 旋转中心
	int i, j;
	for (i = 0; i < src.rows; i++)
		for (j = 0; j < src.cols; j++)
		{
			Point curr_p = { 0 };

			// 绕中心旋转
			curr_p.x = (i - src.rows / 2) * cos(angle) - (j - src.cols / 2) * sin(angle);
			curr_p.y = (i - src.rows / 2) * sin(angle) + (j - src.cols / 2) * cos(angle);

			// 对应于新坐标系中坐标
			curr_p.x += new_R / 2;
			curr_p.y += new_C / 2;

			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[0] = src.at<Vec3b>(i, j)[0];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[1] = src.at<Vec3b>(i, j)[1];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[2] = src.at<Vec3b>(i, j)[2];
		}

	imshow("Rotated", Rotated_img);
	waitKey();

	return 0;



}
代码效果如下：


可以看到，图像变得模糊了，准确地说是图像中有的位置没有像素，这就有点郁闷了，然后参看了MLK的博客：点击打开链接，了解到我现在使用的旋转方法为：正向映射法，使用正向映射法时，由于求旋转坐标过程中会出现小数，直接取整会导致有的像素取不到值，所以旋转过程一半采用反向映射法，然后进行插值使图像连续。

反向映射+插值的代码正在写~~

双线性插值原理可以参考博客：点击打开链接，向大佬致敬！

代码如下：

#include <opencv2/opencv.hpp>
#include <math.h>

using namespace cv;
using namespace std;

int main()
{
	Mat src = imread("1.jpg");
	float angle = 30 * CV_PI / 180;

	// 保证图像宽和高都为正
	int new_R = ceil( abs(src.cols * cos(angle)) + abs(src.rows * sin(angle)) );
	int new_C = ceil( abs(src.cols * sin(angle)) + abs(src.rows * cos(angle)) );

	Mat Rotated_img = Mat::zeros(new_R, new_C, CV_8UC3);
	Mat Rotated_img_back = Mat::zeros(new_R, new_C, CV_8UC3);

	// 旋转
	// 前向映射法
	// 1、旋转中心
	Point C = Point(src.rows / 2, src.cols / 2);  // 旋转中心
	int i, j, k;
	for (i = 0; i < src.rows; i++)
		for (j = 0; j < src.cols; j++)
		{
			Point curr_p = { 0 };

			// 绕中心旋转
			curr_p.x = (i - src.rows / 2) * cos(angle) - (j - src.cols / 2) * sin(angle);
			curr_p.y = (i - src.rows / 2) * sin(angle) + (j - src.cols / 2) * cos(angle);

			// 对应于新坐标系中坐标
			curr_p.x += new_R / 2;
			curr_p.y += new_C / 2;

			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[0] = src.at<Vec3b>(i, j)[0];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[1] = src.at<Vec3b>(i, j)[1];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[2] = src.at<Vec3b>(i, j)[2];
		}

	// 反向映射
	for (i = 0; i < Rotated_img_back.rows; i++)
		for (j = 0; j < Rotated_img_back.cols; j++)
		{
			Point2f curr_p = { 0 };

			// 将旋转中心移到图像中心
			float cx = i - Rotated_img_back.rows / 2.0;
			float cy = j - Rotated_img_back.cols / 2.0;

			// 反向投影回原坐标系
			curr_p.x = cx * cos(angle) + cy * sin(angle) + src.rows / 2;
			curr_p.y = -cx * sin(angle) + cy * cos(angle) + src.cols / 2;

			// 双线性插值，四邻域
			int low_x = 0;
			int low_y = 0;
			int high_x = 0;
			int high_y = 0;

			// ceil 向上取整, floor 向下取整
			low_x = floor(curr_p.x);
			low_y = floor(curr_p.y);
			high_x = ceil(curr_p.x);
			high_y = ceil(curr_p.y);

			float f0 = 0, f1 = 0;
			if ( (low_x >= 0 ) && (low_y >= 0)  && 
				(high_x < src.cols) && (high_y < src.rows))
			{
				for (k = 0; k < 3; k++)
				{
			
					f0 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, low_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, low_y)[k];
					f1 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, high_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, high_y)[k];
					
					Rotated_img_back.at<Vec3b>(i, j)[k] =(high_y - curr_p.y) * f0 + (curr_p.y - low_y) * f1;
				}
				
			}


		}


	imshow("src", src);
	imshow("Rotated", Rotated_img);
	imshow("Rotated_back", Rotated_img_back);
	waitKey();

	return 0;



}
效果如下：


可以看到，旋转后，图片中有两条直线，原因是在进行双线性插值时，可能图片映射到原图时，刚好有对应的整数坐标，这里需要进行一下坐标判断，然后，将图片缩放功能加进去了，代码如下：

#include <opencv2/opencv.hpp>
#include <math.h>

using namespace cv;
using namespace std;

int main()
{
	Mat src = imread("1.jpg");
	float angle = 30 * CV_PI / 180;

	// 保证图像宽和高都为正
	int new_R = ceil( abs(src.cols * cos(angle)) + abs(src.rows * sin(angle)) );
	int new_C = ceil( abs(src.cols * sin(angle)) + abs(src.rows * cos(angle)) );

	Mat Rotated_img = Mat::zeros(new_R, new_C, CV_8UC3);
	Mat Rotated_img_back = Mat::zeros(new_R, new_C, CV_8UC3);

	// 旋转
	// 前向映射法
	// 1、旋转中心
	Point C = Point(src.rows / 2, src.cols / 2);  // 旋转中心
	int i, j, k;
	for (i = 0; i < src.rows; i++)
		for (j = 0; j < src.cols; j++)
		{
			Point curr_p = { 0 };

			// 绕中心旋转
			curr_p.x = (i - src.rows / 2) * cos(angle) - (j - src.cols / 2) * sin(angle);
			curr_p.y = (i - src.rows / 2) * sin(angle) + (j - src.cols / 2) * cos(angle);

			// 对应于新坐标系中坐标
			curr_p.x += new_R / 2;
			curr_p.y += new_C / 2;

			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[0] = src.at<Vec3b>(i, j)[0];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[1] = src.at<Vec3b>(i, j)[1];
			Rotated_img.at<Vec3b>(curr_p.x, curr_p.y)[2] = src.at<Vec3b>(i, j)[2];
		}

	//2、 反向映射
	for (i = 0; i < Rotated_img_back.rows; i++)
		for (j = 0; j < Rotated_img_back.cols; j++)
		{
			Point2f curr_p = { 0 };

			// 将旋转中心移到图像中心
			float cx = i - Rotated_img_back.rows / 2.0;
			float cy = j - Rotated_img_back.cols / 2.0;

			// 反向投影回原坐标系
			curr_p.x = cx * cos(angle) + cy * sin(angle) + src.rows / 2;
			curr_p.y = -cx * sin(angle) + cy * cos(angle) + src.cols / 2;

			// 双线性插值，四邻域
			int low_x = 0;
			int low_y = 0;
			int high_x = 0;
			int high_y = 0;

			// ceil 向上取整, floor 向下取整
			low_x = floor(curr_p.x);
			low_y = floor(curr_p.y);
			high_x = ceil(curr_p.x);
			high_y = ceil(curr_p.y);

			// 如果刚好有对应位置
			float f0 = 0, f1 = 0;
			if (abs(low_x - high_x) < 0.1 && abs(low_y - high_y) < 0.1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						Rotated_img_back.at<Vec3b>(i, j)[k] = src.at<Vec3b>(low_x, low_y)[k];
					}
				}

			}
			else if (abs(low_x - high_x) < 0.1 && abs(low_y - high_y) == 1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						Rotated_img_back.at<Vec3b>(i, j)[k] = (high_y - curr_p.y) * src.at<Vec3b>(low_x, low_y)[k] +
							(curr_p.y - low_y) * src.at<Vec3b>(low_x, high_y)[k];
					}
				}
			}
			else if (abs(low_x - high_x) == 1 && abs(low_y - high_y) < 0.1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						Rotated_img_back.at<Vec3b>(i, j)[k] = (high_x - curr_p.x) * src.at<Vec3b>(low_x, low_y)[k] +
							(curr_p.x - low_x) *  src.at<Vec3b>(high_x, high_y)[k];
					}
				}
			}
			else
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{

						f0 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, low_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, low_y)[k];
						f1 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, high_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, high_y)[k];

						Rotated_img_back.at<Vec3b>(i, j)[k] = (high_y - curr_p.y) * f0 + (curr_p.y - low_y) * f1;
					}
				}
			}

		


		}

	// 3、缩放
	float m_scale = 1.2;
	// 保证图像宽和高都为正
	int new_R_s = ceil(m_scale * src.rows);
	int new_C_s = ceil(m_scale * src.cols);

	Mat scale_img = Mat::zeros(new_R_s, new_C_s, CV_8UC3);
	for (i = 0; i < new_R_s; i++)
		for (j = 0; j < new_C_s; j++)
		{
			Point2f curr_p = { 0 };
			curr_p.x = i / m_scale;
			curr_p.y = j / m_scale;

			// 双线性插值，四邻域
			int low_x = 0;
			int low_y = 0;
			int high_x = 0;
			int high_y = 0;

			// ceil 向上取整, floor 向下取整
			low_x = floor(curr_p.x);
			low_y = floor(curr_p.y);
			high_x = ceil(curr_p.x);
			high_y = ceil(curr_p.y);

			// 如果刚好有对应位置
			float f0 = 0, f1 = 0;
			if (abs(low_x - high_x) < 0.1 && abs(low_y - high_y) < 0.1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						scale_img.at<Vec3b>(i, j)[k] = src.at<Vec3b>(low_x, low_y)[k];
					}
				}

			}
			else if (abs(low_x - high_x) < 0.1 && abs(low_y - high_y) == 1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						scale_img.at<Vec3b>(i, j)[k] = (high_y - curr_p.y) * src.at<Vec3b>(low_x, low_y)[k] + 
							                           (curr_p.y - low_y) * src.at<Vec3b>(low_x, high_y)[k];
					}
				}
			}
			else if (abs(low_x - high_x) == 1 && abs(low_y - high_y) < 0.1)
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{
						scale_img.at<Vec3b>(i, j)[k] = (high_x - curr_p.x) * src.at<Vec3b>(low_x, low_y)[k] +
							(curr_p.x - low_x) *  src.at<Vec3b>(high_x, high_y)[k];
					}
				}
			}
			else 
			{
				if ((low_x >= 0) && (low_y >= 0) &&
					(high_x < src.cols) && (high_y < src.rows))
				{
					for (k = 0; k < 3; k++)
					{

						f0 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, low_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, low_y)[k];
						f1 = (high_x - curr_p.x) * src.at<Vec3b>(low_x, high_y)[k] + (curr_p.x - low_x) * src.at<Vec3b>(high_x, high_y)[k];

						scale_img.at<Vec3b>(i, j)[k] = (high_y - curr_p.y) * f0 + (curr_p.y - low_y) * f1;
					}
				}
			}


			


		}






	imshow("src", src);
	imshow("Rotated", Rotated_img);
	imshow("Rotated_back", Rotated_img_back);
	imshow("Scale_img", scale_img);
	waitKey();

	return 0;



}
效果如下：



图像处理篇：图像预处理——从数据到模型的桥梁
QQ_778132974的博客
03-17 2446
图像预处理既是科学，也是艺术。它需要扎实的理论基础，也需要灵活的实践技巧。通过本文的学习，你应该已经掌握了图像预处理的核心技术与最佳实践。未来，随着AI技术的不断发展，图像预处理将变得更加智能化和自动化，为计算机视觉任务提供更强大的支持。参考资料OpenCV官方文档Albumentations库TensorFlow预处理指南。
图像处理二：仿射变换和透视变换
简简单单
12-04 2139
一、仿射变换(Affine Transformation)         放射变换（平面变换、二维坐标变换）：是空间直角坐标系的变换，从一个二维坐标变换到另一个二维坐标，仿射变换是一个线性变换，保持了图像的“平行性”和“平直性”，即图像中原来的直线和平行线，变换后仍然保持原来的直线和平行线。        仿射变换比较常用的特殊变换有平移(Translation)、缩放(Scale)、翻转(...
数字图像处理代码平移变换，对称
10-26
用C++编写的有关数字图像处理的代码，比如平移和对称变换邓。
图像处理——图像变换
03-08 698
图像处理——图像变换 操作环境：windows10系统，spyder3编辑器，python3语言。 定义：通过对图像进行各种便函，逐点改变源图像像素灰度值的相关方法。 目的：改善画质。 主要内容：图像的线性变换与非线性变换，主要为图像反转，对数变换等，图像...
图像处理-图像变换
lufylegend_fans的博客
10-15 1726
先让我们用大白话来讲解一下什么是直方图，将一个灰度图中各种灰度等级的像素点数量列出来。一般图像的像素点大小是8比特，也就是他的灰度等级是0-255。然后我们计算0灰度等级的像素个数，1灰度等级的像素个数…254灰度等级的像素个数，255灰度等级的像素个数。然后按照顺序列成一张表。这就是直方图。当然只是直方图的其中一种表现方式，你也可以计算出每个灰度等级的像素数量占总像素数量的比重，这也就是归一化（这个计算过程叫做PDF，概率密度函数）。后面我们所说的直方图一般都是这个归一化的直方图。
图像的变换
10-15
1、了解图像的傅里叶变换、余弦变换等原理； 2、掌握图像变换的Matlab编程。
MATLAB图像处理：小波变换原理与应用详解
最新发布
weixin_31268759的博客
02-15 3214
小波变换是一种多分辨率分析工具，能够同时在时域和频域提供信号的局部特征信息，广泛应用于图像去噪、压缩、增强和特征提取等领域。本文将系统解析 一维及二维小波变换的数学原理，结合MATLAB代码实战。
数字图像处理实验二 图像傅里叶变换 实验报告 附代码 结果 数据
12-16
实验报告——数字图像处理：图像傅里叶变换 在图像处理领域，傅里叶变换是一种重要的工具，它能够将图像从空间域转换到频域，从而揭示图像的频率特性。本实验旨在深入理解图像频域处理的意义，掌握二维傅里叶变换的...
基于MATLAB的图像处理技术：实验二 图像几何变换
m0_68526732的博客
01-17 1534
摘要：本文是我们学习MATLAB图像处理技术实验的第二节：图像几何变换
图像变换（Image Warping and Morphing）
12-08
该pdf为一个ppt讲义的pdf版本，涉及到现在2D图像的基本变换，及其实例的公式推导，比如平移、旋转等等。
图像变换的基本模型
02-10
变换模型是指根据待匹配图像与背景图像之间几何畸变的情况，所选择的能最佳拟合两幅图像之间变化的几何变换模型。可采用的变换模型有如下几种:刚性变换、仿射变换、透视变换和非线形变换等
基本的图像操作和处理（计算机视觉）
qq_47321558的博客
03-16 3697
文章目录一、图像的灰度变换原理介绍：代码示例：结果展示：二、图像轮廓和直方图1.图像轮廓2.直方图处理原理介绍直方图的性质3.代码示例4.结果展示三，直方图均衡化原理介绍均衡化的具体实现代码实现：结果展示：四，图像模糊1，高斯模糊高斯模糊的原理：代码实现结果展示 一、图像的灰度变换 原理介绍： 首先我们知道一张图片的所有颜色都可以通过RGB值调节进行表示，如果是一张彩色图片则RBG值不一定相同，将彩色图片灰度化就是指的是将彩色图片变成黑白的，这时候的RBG三个通道的值是相同的，就是将一幅色彩图像转化为灰度
MATLAB图像变换
翱翔云端的专栏
04-17 5394
一、综述 图像变换可以分为正交变换（积分变换）和几何变换两种。积分变换主要有离散傅里叶变换、离散余弦变换、小波变换等，其基本思想就是将图像信号从空间域变换到频率域。为什么要这样处理呢？目的是简化问题的求解。举个例子，要在空间域中做卷积运算，其难度相当大，但是通过离散傅里叶变换，可以将空间域中的卷积运算转化为频率域中的乘法运算，化繁为简。所以，求解这类问题的一般思路是： 1）从空间域转化到频率域
数字图像变换
m0_37867411的博客
03-20 569
图像的几何变换和Hough变换
【图像处理】：图像的透视变换
热门推荐
weixin_44322778的博客
04-06 1万+
函数cv2.warpAffine()函数以cv2.getAffineTransform(src, dst)获得的转换矩阵M为参数，将src中的点仿射到dst中，函数cv2.getAffineTransform(src, dst)对指定的点完成映射之后，将所有其他点的映射关系按照指定点的关系确定。在目标图像上选四个坐标点，分别为B： (X’0,Y’0),(X’1,Y’1),(X’2,Y’2),(X’3,Y’3)在源图像上选四个坐标点，分别为A： （x0,y0),(x1,y1),(x2,y2),(x3,y3)
图像像素操作
qq_18741601的博客
06-11 425
灰度图像：img.at<uchar>(y,x)=128; RGB图像：img.at<Vec3b>(y,x)[0]=128; lVec3b对应三通道的顺序是blue、green、red的uchar类型数据。 lVec3f对应三通道的float类型数据 #include<opencv2/opencv.hpp> #include<iostream>...
OpenCV（总结篇）图像逐像素访问（三种操作：指针、迭代器、at()函数）
great_yzl的博客
08-12 4536
目录 概述 1、指针访问 2、迭代器访问 3、at()函数访问 总代码 效果 参考资料 概述 访问图像像素值是图像处理的基本操作。OpenCV提供了很多访问方式，比较常用的三种方式： （1） 通过指针访问 （逐通道） （2） 通过迭代器访问 （逐像素） （3） 动态地址计算，通过at()函数实现 方法比较： （1）用指针访问像素，速度最快；但在彩色图像处理中，如果要单独对某一个颜色分量处理，则需要通过数学公式计算，不是很直观； （2）推荐用通过迭代器访问像素，速度快，而且提取BGR...
opencv的at，iterator,z指针的用法
ture_dream的博客
03-16 2168
对于单通道图像，其元素类型一般为 对于单通道图像，其元素类型一般为 8U （即 8位无符号整数），当然也可以 是 16S 、32F32F 等；这些类型可以直接用 ucharucharucharuchar 、short short short、floatfloat float等 C/C++语言中的基本 数据类型表达。  如果多通道图像，RGB 彩色图像，需要用三个通道来表示。在这种情况下，如果依然
图像处理技术：小波变换分解与重构
### 图像处理中的小波变换 在数字图像处理领域，小波变换是一种强大的数学工具，用于对图像进行多分辨率分析。这种方法允许我们从不同的尺度观察图像，从而能够在分析图像的同时保持时间和频率的局部化特性。在本篇...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值