半色调算法

最新推荐文章于 2023-10-08 13:59:20 发布
最新推荐文章于 2023-10-08 13:59:20 发布
阅读量4.8k 收藏 20
点赞数 4
分类专栏： 【opencv学习】 文章标签： 算法 计算机视觉 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doubleintfloat/article/details/121285117
版权

参考：https://blog.csdn.net/majinlei121/article/details/49335693
Y(亮度)=(0.299R)+(0.587G)+(0.114*B)

半色调技术是 指用少量的色彩将一幅连续色调图像(如灰度图像和彩色图像)量化为一幅二值图像或是只有少数几种色彩的彩色图像，并且量化后图像在一定距离的视觉效果和原始图像相似的技术 ；

目前半色调技术最普遍的分类法是按照它的处理方式分为：抖动法，误差扩散法，迭代法三大类。
从整体上看，误差扩散的效果是很好的。目前已有的最好的半色调效果仍是基于误差扩散方法。误差扩散也有不足之处。从速度上看，中值阈值法对每个像素只做一次比较运算，速度很快。而误差扩散要进行大量的乘除法运算，速度相对较慢。

下面是我自己


#include <iostream>
#include <opencv.hpp>
#include <opencv\highgui.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>


using namespace cv;
using namespace std;

uchar findfit(uchar p_param)
{
	//0,16,32,
	uchar m = p_param / 16;
	uchar n = p_param % 16;
	if (n <=8)
	{
		return m*16;
	}
	else
	{
		return (m + 1)*16;
	}
}

void fun1(Mat img)
{
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_dst;
	int len = sizeof(ushort);
	int len1 = sizeof(uchar);
	for (int i = 0; i < height; i++)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_dst = dst.ptr<uchar>(i);
		for (int j = 0; j < width; ++j)
		{
			p_dst[j] = (p_img[j] - minv) / (maxv - minv) * 255;
			p_dst[j] = p_dst[j] / 64;
			p_dst[j] = p_dst[j] * 64;
			//cout << (int)p_dst[j] << "  ";
		/*	if (p_dst[j] > 192)
			{
				p_dst[j] = 255;
			}
			else if(p_dst[j] > 128)
			{
				p_dst[j] = 128;
			}
			else if (p_dst[j] > 64)
			{
				p_dst[j] = 64;
			}
			else
			{
				p_dst[j] = 0;
			}*/
			//p_dst[j] = p_img[j*3/2];
			//下面是失真较大的转换方法
			//int temp = img.at<ushort>(i, j);
			//dst.at<uchar>(i, j) = temp;
		}
	}
	//   dst = img;
	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("2", 0);
	cvResizeWindow("2", 192 * 3, 216 * 3);
	imshow("2", dst);
	imwrite("E:\\4.jpg", dst);
}


void fun2(Mat img)
{
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_dst;
	int len = sizeof(ushort);
	int len1 = sizeof(uchar);
	for (int i = 0; i < height; i++)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_dst = dst.ptr<uchar>(i);
		for (int j = 0; j < width; ++j)
		{
			p_dst[j] = (p_img[j] - minv) / (maxv - minv) * 255;
			if (p_dst[j] > 192)
			{
				p_dst[j] = 255;
			}
			else if(p_dst[j] > 128)
			{
				p_dst[j] = 128;
			}
			else if (p_dst[j] > 64)
			{
				p_dst[j] = 64;
			}
			else
			{
				p_dst[j] = 0;
			}
		}
	}
	//   dst = img;
	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("3", 0);
	cvResizeWindow("3", 192 * 3, 216 * 3);
	imshow("3", dst);
	imwrite("E:\\4.jpg", dst);
}


void fun3(Mat img)
{
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_dst;
	int len = sizeof(ushort);
	int len1 = sizeof(uchar);
	for (int i = 0; i < height; i++)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_dst = dst.ptr<uchar>(i);
		for (int j = 0; j < width; ++j)
		{
			p_dst[j] = (p_img[j] - minv) / (maxv - minv) * 255;
			p_dst[j] = p_dst[j] & 0B11000000;
		}
	}
	//   dst = img;
	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("4", 0);
	cvResizeWindow("4", 192 * 3, 216 * 3);
	imshow("4", dst);
	imwrite("E:\\4.jpg", dst);
}

//误差扩散法1
void floydsetin(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height-2;++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		
		p_lw = img.ptr<uchar>(i+1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width-2; ++j)
		{
			if (p_img[j] > 128)
			{
				tep = 255;
			}
			else
			{
				tep = 0;
			}
			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("5", 0);
	cvResizeWindow("5", 192 * 3, 216 * 3);
	imshow("5", dst);
	imwrite("E:\\5.jpg", dst);
}

//误差扩散法2灰阶
void floydsetin_2(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			if (p_img[j] > 128)
			{
				p_dst[j] = 255;
				tep = 255;
			}
			else
			{
				p_dst[j] = 0;
				tep = 0;
			}
			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("2灰阶", 0);
	cvResizeWindow("2灰阶", 192 * 3, 216 * 3);
	imshow("2灰阶", dst);
	imwrite("E:\\2灰阶.jpg", dst);
}

//误差扩散法2灰阶
void my2(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			if (p_img[j] > 127)
			{
				p_dst[j] = 255;
				tep = 255;
			}
			else
			{
				p_dst[j] = 0;
				tep = 0;
			}
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("my2灰阶", 0);
	cvResizeWindow("my2灰阶", 192 * 3, 216 * 3);
	imshow("my2灰阶", dst);
	imwrite("E:\\my2灰阶.jpg", dst);
}

//误差扩散法4灰阶
void floydsetin_4(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			if (p_img[j] > 192)
			{
				p_dst[j] = 192;
				tep = 192;
			}
			else if (p_img[j] > 128)
			{
				p_dst[j] = 128;
				tep = 128;
			}
			else if (p_img[j] > 64)
			{
				p_dst[j] = 64;
				tep = 64;
			}
			else
			{
				p_dst[j] = 0;
				tep = 0;
			}
			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("4灰阶", 0);
	cvResizeWindow("4灰阶", 192 * 3, 216 * 3);
	imshow("4灰阶", dst);
	imwrite("E:\\4灰阶.jpg", dst);
}

//误差扩散法8灰阶
void floydsetin_8(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			if (p_img[j] > 224)
			{
				p_dst[j] = 224;
				tep = 224;
			}
			else if (p_img[j] > 192)
			{
				p_dst[j] = 192;
				tep = 192;
			}
			else if (p_img[j] > 160)
			{
				p_dst[j] = 160;
				tep = 160;
			}
			else if (p_img[j] > 128)
			{
				p_dst[j] = 128;
				tep = 128;
			}
			else if (p_img[j] > 96)
			{
				p_dst[j] = 96;
				tep = 96;
			}
			else if (p_img[j] > 64)
			{
				p_dst[j] = 64;
				tep = 64;
			}
			else if (p_img[j] > 32)
			{
				p_dst[j] = 32;
				tep = 32;
			}
			else
			{
				p_dst[j] = 0;
				tep = 0;
			}
			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("8灰阶", 0);
	cvResizeWindow("8灰阶", 192 * 3, 216 * 3);
	imshow("8灰阶", dst);
	imwrite("E:\\8灰阶.jpg", dst);
}

//误差扩散法16灰阶
void floydsetin_16(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			for (int m = 15; m >= 0; --m)
			{
				if (p_img[j] > 16*m)
				{
					p_dst[j] = 16 * m;
					tep = 16 * m;
					break;
				}
			}

			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("16灰阶", 0);
	cvResizeWindow("16灰阶", 192 * 3, 216 * 3);
	imshow("16灰阶", dst);
	imwrite("E:\\16灰阶.jpg", dst);
}

//误差扩散法16灰阶
void floydsetin_16_001(Mat img)
{
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			/*for (int m = 15; m >= 0; --m)
			{
				if (p_img[j] > 16 * m)
				{
					p_dst[j] = 16 * m;
					tep = 16 * m;
					break;
				}
			}*/
			int te = findfit(p_img[j]);
			p_dst[j] = te;
			tep = te;

			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("16灰阶_001", 0);
	cvResizeWindow("16灰阶_001", 192 * 3, 216 * 3);
	imshow("16灰阶_001", dst);
	imwrite("E:\\16灰阶_001.jpg", dst);
}
//误差扩散法n灰阶
void floydsetin_16(Mat img , int m)
{
	if (m <= 0)
	{
		return;
	}
	double a = 0.4375;
	double b = 0.1875;
	double c = 0.3125;
	double d = 0.0625;
	DWORD Start_time = GetTickCount(); //计时开始
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	//dst = img;
	double minv = 0.0, maxv = 0.0;
	double* minp = &minv;
	double* maxp = &maxv;
	minMaxIdx(img, minp, maxp);  //取得像素值最大值和最小值
	int t = CV_8UC1;
	//用指针访问像素，速度更快
	uchar* p_img;
	uchar* p_lw;
	uchar* p_dst;
	int tep = 0;
	int err = 0;
	int step = 256 / m;
	for (int i = 0; i < height - 2; ++i)
	{
		p_img = img.ptr<uchar>(i);//获取每行首地址
		p_lw = img.ptr<uchar>(i + 1);
		p_dst = dst.ptr<uchar>(i);
		for (int j = 2; j < width - 2; ++j)
		{
			for (; m >= 0; --m)
			{
				if (p_img[j] > step * (m-1))
				{
					p_dst[j] = step * (m)-1;
					tep = step * (m)-1;
					if (m == 0)
					{
						p_dst[j] = 0;
						tep = 0;
					}
					break;
				}
			}

			err = p_img[j] - tep;
			p_dst[j + 1] += err * a;
			p_lw[j - 1] += err * b;
			p_lw[j] += err * c;
			p_lw[j + 1] += err * d;
		}
	}

	DWORD End_time = GetTickCount(); //计时结束
	cout << "Time used：" << End_time - Start_time << " ms" << '\n';
	namedWindow("灰阶", 0);
	cvResizeWindow("灰阶", 192 * 3, 216 * 3);
	imshow("灰阶", dst);
	imwrite("E:\\灰阶.jpg", dst);
}


int main()
{	
	Mat img = imread("E:\\1.jpg", 0);//加载图像;
	if (img.empty())
	{
		cout << "打开文件失败" << endl;
		return -1;
	}
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片
	dst = img;
	imwrite("E:\\灰阶原图.jpg", dst);

	int m_channel = 	(&img)->channels();
	Size m_size = img.size();
	cout << m_size << endl;
	cout << img.total() << endl;
	cout << img.rows << "   " << img.cols << endl;
	//cout << img << endl;
	cout << img.isContinuous() << endl;
	cout << img.type()<< endl;
	cout << CV_8UC1 << endl;
	cout << CV_8UC2 << endl;
	cout << CV_8UC3 << endl;

	for (int r = 0; r < img.rows; ++r)
	{
		const uchar* ptr = img.ptr<uchar>(r);

		for (int c = 0; c < img.cols; ++c)
		{
			//cout << ptr[c] << ",";
		}
		//cout << endl;
	}
	namedWindow("1", WINDOW_NORMAL);
	cvResizeWindow("1", 192 * 3, 216 * 3);
	imshow("1", img);


	//方法1
	//fun1(img);
	//fun2(img);
	//fun3(img);
	//my2(img);
	//floydsetin_2(img);
	//floydsetin_2(img);
	//floydsetin_4(img);
	//floydsetin_8(img);
	//floydsetin_16(img);
	floydsetin_16_001(img);
	findfit(19);
	waitKey(0);
	system("pause");

	return 0;
}

在这里插入图片描述

越甲八千
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像半色调技术抖动算法
05-15
课程大作业，基于MFC完成多种半色调技术
stucki 半色调 图像处理 二值 matlab
04-13
可应用于数字图像处理，将灰度图像或者彩色图像R,G,B某个通道的图像转换为二值图像，也称半色调处理
半色调打印
04-22
半色调打印，使用C语言以及opencv写的。可以用来参考
图像的阈值分割和半色调算法实现
12-31
实现了图像的阈值分割算法和半色调抖动算法，程序可运行，带有MFC界面
halftone:将普通图像转换为半色调图像-matlab开发
05-30
这些程序将普通图像转换为半色调图像。
半色调(Halftoning)技术
BryantDaiJB的博客
08-05 1323
半色调技术是指用少量的色彩将一幅连续色调图像(如灰度图像和彩色图像)量化为只有少数几种色彩的彩色图像或是一幅二值图像，并且量化后图像在一定距离的视觉效果和原始图像相似的技术。对于二阶调来说，就是用黑白两种颜色，来展示不同深度的灰度，从而模拟出灰度图像，简单来说就是让二阶调的图像产生连续调的感觉。这项技术被广泛用于打印机上。Notice：本文暂时只讨论灰度图像的半色调方法有序抖动算法比较简单，且具有较好的半色调图像质量。
半色调技术
JHFUSFLSJH的博客
01-10 2235
半色调技术 matlab
半色调技术简介
热门推荐
松子茶的专栏
11-06 1万+
连续调图像与半色调图像 在我们的日常生活中，所遇到的图像可大致分为两大类：连续调图像(Continuuos-Tone Image)和半色调图像(Haltfnoe Image)。如我们常见的彩色照片就是一种连续调图像，在这种图像上，存在着由淡到浓或由深到浅的色调变化并且浓淡或深浅是以单位面积成像物质颗粒密度来构成的，并且这种图像的深浅变化有无数多级。另外印刷工艺中的照相分色底片的连续调，是由单位面积
【光栅和蛇形误差扩散半色调】基于Floyd-Steinberg算法进行误差扩散半色调研究（Matlab代码实现）
最新发布
weixin_46039719的博客
10-08 489
除了标准的Floyd-Steinberg算法，还有其他一些改进的误差扩散半色调算法，例如Jarvis, Judice和Ninke算法，以及Stucki算法等。通过使用Floyd-Steinberg算法进行误差扩散半色调，可以使得图像在仅使用有限的颜色时，仍然能够呈现出较高的细节和质量。总而言之，光栅和蛇形误差扩散半色调是一种有效的图像处理技术，可以在有限的颜色空间中生成具有高质量细节的图像。接下来，对于每个像素点，根据其当前的RGB值和最近的可用颜色进行比较，找到最匹配的颜色。行百里者，半于九十。
基于全息水印印刷防伪的半色调算法
03-10
分析了数字全息水印技术和数字图像半色调技术中的调幅半色调、调频半色调和AM/FM混合半色调3类主要技术的优势。探讨了将数字全息水印和数字图像半色调化技术紧密结合起来的数字全息水印防伪技术,并介绍了其原理、特点及应用。
尺度相关系数融合数字半色调算法
02-07
混合误差测度函数的建立是利用多尺度小波系数融合建立的边界误差测度函数和改进的K-means聚类法建立的区域误差测度函数。小波域多尺度信息通过二维离散小波变换方法得到，从空间域到小波域的变换为原来的二维图像提供了一种紧凑的多尺度表征形式。利用这一紧凑的表征形式从少数幅值较大的小波系数中捕获图像的关键特征。应用基于区域的直接二值搜索方法最小化初始图像和半色调图像的误差，得到最优数字半色调图像。实验结果表明，该算法与基于模型的数字半色调（LSMB）算法比较，半色调图像均方误差值（MSEv）值降低了0.127，峰值信噪比（PSNR）值提高了12.72 dB。对原图和半色调图像进行频域变换，通过分析半色调噪声频谱图发现，半色调噪声谱仅分布在中、高频段，无很强的周期分量，且局部的频谱分量从低到高逐步增加，人眼视觉不敏感。对4种不同像素尺度进行半色调后，该方法计算时间均小于LSMB算法，从这个角度来看，该算法具有较快的收敛速度。
基于网点形状的半色调算法
03-26
基于网点形状的半色调算法
数字图像处理基于半色调打印技术
03-17
本实验采用半色调技术对图像进行打印和显示。半色调技术是一种基于点模式的灰度级图像打印方案。在本实验中，给出了用点模式近似表示的10个灰度级，每一个灰度级用一个3*3的点模式表示。用黑点全部填充的3*3近似表示灰度级为0的黑色灰度级，全部填充白点的3*3模式近似表示灰度级为9的白色灰度级，其他的点模式表示这二者之间的灰度级。实验中将利用的这种半色调技术对给定的图像的进行打印进行分析。并设计一个大小渐变的测试图像的程序来检验所设计的半色调技术打印方案。利用这种方案进行图像的打印时将减小图像的空间分辨率，将有所增加其几何面积，以防当原始图像过大时输出图像不能完整地打印出原图像，在程序中增加了条件进行改进。
颜色增强算法Opencv
09-14
opencv实现图像颜色增强算法，vs2013+opencv2.4.13 实现。、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
论文研究-基于K-means聚类的数字半色调算法.pdf
07-22
利用K-means聚类法将灰度图像划分成聚类分区, 在每个聚类分区应用最小平方法least-squares最小化二值半色调图像和原始灰度级图像之间的平方误差, 所构造的半色调算法与基于模型的最小平方法LSMB算法相比, 随着聚类...
印刷品水印图像的半色调算法比较
02-09
对Bayer抖动、误差扩散和绿噪声3种半色调算法进行了分析比较。利用离散小波变换将水印信息嵌入宿主图像,采用峰值信噪比对3种算法生成的半色调图像质量进行客观评价;用归一化相关系数衡量半色调图像提取的水印质量;以...
基于K-means聚类的数字半色调算法
02-24
利用K-means聚类法将灰度图像划分成聚类分区，在每个聚类分区应用最小平方法 （least-squares）最小化二值半色调图像和原始灰度级图像之间的平方误差，所构造的半色调算法与基于模型的最小平方法（LSMB）算法...
python实现半色调技术图像转换
ajream的博客
03-07 764
半色调技术 图像转换 python实现
根据RGB各个分量图像的情况讨论该彩色图像的亮度、色调等性质
06-07
RGB图像由红、绿、蓝三个分量图像组成。我们可以通过这些分量图像的情况来讨论该彩色图像的亮度、色调等性质。 1. 亮度：亮度是指图像的明暗程度。我们可以通过计算RGB三个分量的平均值来估算亮度。如果红、绿、蓝三个分量的平均值相等，那么该彩色图像的亮度为灰度。 2. 色调：色调是指图像的颜色种类。我们可以通过观察RGB三个分量的强度比例来确定色调。如果红分量的强度远大于绿、蓝分量，那么该彩色图像的色调为红色；如果绿分量的强度远大于红、蓝分量，那么该彩色图像的色调为绿色；如果蓝分量的强度远大于红、绿分量，那么该彩色图像的色调为蓝色。 3. 饱和度：饱和度是指图像颜色的纯度。我们可以通过计算RGB三个分量的最大值与最小值之差来确定饱和度。如果三个分量的最大值与最小值之差相等，那么该彩色图像的饱和度为0，即为灰度图像；如果三个分量的最大值与最小值之差越大，那么该彩色图像的饱和度越高，颜色越鲜艳。 总之，通过分析RGB三个分量的情况，我们可以了解彩色图像的亮度、色调和饱和度等性质。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值