半色调算法

最新推荐文章于 2023-10-08 13:59:20 发布
原创 最新推荐文章于 2023-10-08 13:59:20 发布 · 5.3k 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #计算机视觉 #c++

参考：https://blog.youkuaiyun.com/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;
}

在这里插入图片描述

半色调技术简介
松子茶的专栏
11-06 1万+
连续调图像与半色调图像 在我们的日常生活中，所遇到的图像可大致分为两大类：连续调图像(Continuuos-Tone Image)和半色调图像(Haltfnoe Image)。如我们常见的彩色照片就是一种连续调图像，在这种图像上，存在着由淡到浓或由深到浅的色调变化并且浓淡或深浅是以单位面积成像物质颗粒密度来构成的，并且这种图像的深浅变化有无数多级。另外印刷工艺中的照相分色底片的连续调，是由单位面积
基于半色调技术的图像打印程序(Image Printing Program Based on Halftoning)
liyuefeilong的专栏
01-25 6861
摘 要：本实验采用半色调技术对图像进行打印和显示。使用实验后面所给出了用点模式近似表示的0到9，10个灰度级来表示一张图片。每一个灰度级用一个3*3的黑白点模式表示。用3*3全黑点近似表示灰度级为0的黑色灰度级，3*3全白点近似表示灰度级为9的白色灰度级。其它的点模式表示这二者之间的灰度级。由于用3*3个像素点代替原来一个像素点，因此在有限的打印面积上需要考虑图像尺寸的大小，故需要对输入图像进行预处理。在此基础上，编写一个生成尺寸为256*256大小的灰度渐变测试图像的程序。输出图像第1列像素灰度为0
Unity+shader实现星之卡比新星同盟切屏效果
10-23
循序渐进的重现星之卡比新星同盟切屏效果。包含halftone图形的几种算法，mask贴图的旋转缩放。
半色调(Halftoning)技术
BryantDaiJB的博客
08-05 5514
半色调技术是指用少量的色彩将一幅连续色调图像(如灰度图像和彩色图像)量化为只有少数几种色彩的彩色图像或是一幅二值图像，并且量化后图像在一定距离的视觉效果和原始图像相似的技术。对于二阶调来说，就是用黑白两种颜色，来展示不同深度的灰度，从而模拟出灰度图像，简单来说就是让二阶调的图像产生连续调的感觉。这项技术被广泛用于打印机上。Notice：本文暂时只讨论灰度图像的半色调方法有序抖动算法比较简单，且具有较好的半色调图像质量。
半色调技术
JHFUSFLSJH的博客
01-10 2941
半色调技术 matlab
数字图像处理与应用——半色调技术
li1998zk的博客
01-29 6625
右图为一个二值图像，即非0即1，但由于人眼系统的局限性（类似于低通滤波器），我们关注于区域级别的信息而不是像素级，在一定距离时，会感觉到右图是一副灰度图（错觉illusion），即人眼系统对像素值进行了加权（看到的某些像素应该是介于(0, 1)直接的值）。 有效的数字半色调可以以最小的成本大幅提高渲染图像的质量。 为什么要用到半色调技术？ 降低灰度/颜色分辨率的例子 激光打印机，要么落墨、要么不落墨 半色调是图像的字长缩减 半色调试图在保持质量和空间分辨率的同时再现全范围的灰色/彩色..
论文研究-基于K-means聚类的数字半色调算法.pdf
07-22
利用K-means聚类法将灰度图像划分成聚类分区, 在每个聚类分区应用最小平方法least-squares最小化二值半色调图像和原始灰度级图像之间的平方误差, 所构造的半色调算法与基于模型的最小平方法LSMB算法相比, 随着聚类...
精选资源
基于网点形状的半色调算法
03-26
标题《基于网点形状的半色调算法》中蕴含的知识点： 1. 半色调技术与网点形状：半色调技术是印刷行业常用的一种图像处理技术，其主要作用是在减少图像颜色和细节的情况下，使图像看起来具有连续色调的视觉效果。...
精选资源
基于K-means聚类的数字半色调算法
02-24
利用K-means聚类法将灰度图像划分成聚类分区，在每个聚类分区应用最小平方法 （least-squares）最小化二值半色调图像和原始灰度级图像之间的平方误差，所构造的半色调算法与基于模型的最小平方法（LSMB）算法...
精选资源
印刷品水印图像的半色调算法比较
02-09
对Bayer抖动、误差扩散和绿噪声3种半色调算法进行了分析比较。利用离散小波变换将水印信息嵌入宿主图像,采用峰值信噪比对3种算法生成的半色调图像质量进行客观评价;用归一化相关系数衡量半色调图像提取的水印质量;以...
数字图像半色调技术抖动算法
05-15
课程大作业，基于MFC完成多种半色调技术
图像的阈值分割和半色调算法实现
12-31
实现了图像的阈值分割算法和半色调抖动算法，程序可运行，带有MFC界面
MATLAB: 图像半色调（halftone）显示
01-27
文章《MATLAB: 图像半调（halftone）显示和抖动（dither）显示》的对应实验1代码。
关联分析matlab代码-Digital-Halftoning:该存储库包含用于数字半色调技术的MATLAB和Python代码
05-26
关联分析matlab代码数字半音调 该存储库包含用于数字半色调技术的MATLAB和Python代码 提供的代码 MATLAB： 拜耳 乌利希尼 点扩散（dotdiff.m：可以执行Knuth和Mese-Vaidhyanathan点扩散） 错误扩散（floyd_serp.m：可以执行floyd-steinberg错误扩散，errdiff.m：在执行过程中将被调用） 直接二进制搜索（DBS）（EDBS.m：有效DBS） Python 拜耳半色调 Ulichney半色调 弗洛伊德-施泰因贝格误差扩散 **还包括用于点过程统计的代码：源代码取自Modern Digital Halftoning：有关详细信息，请参阅软件指南。 有关详细信息，请参阅博客： 参考纸： 郭景明和S.Sankarasrinivasan。 “数字半色调数据库（DHD）：对半色调类型的全面分析。” 2018年亚太信号和信息处理协会年度峰会和会议（APSIPA ASC）。 IEEE，2018年。
半色调算法：蓝噪声模板VOIDandCLUSTER算法
不惑之年的新码农
05-26 2669
最近一直在关注半色调算法。其中的蓝噪声模板法算法简单、运行速度快，是半色调算法中一种常用算法。void and cluster算法是一种常用的生成蓝噪声模板的方法。这几天认真研究了这一算法，特将算法的基本情况作一简单梳理，方便以后查阅。 算法的目标： 生成一个用于对图像进行半色调处理的蓝噪声模板。对一个N*N的初始数组，通过算法处理后，数组的元素值是0-（N*N-1）之间的。用于半色调处理时，需要进行归一化。 算法的主要思想： 通过计算一个1位（只有黑和白，也就是0和1）的BINARAY图像的所有点
【光栅和蛇形误差扩散半色调】基于Floyd-Steinberg算法进行误差扩散半色调研究（Matlab代码实现）
weixin_46039719的博客
10-08 885
除了标准的Floyd-Steinberg算法，还有其他一些改进的误差扩散半色调算法，例如Jarvis, Judice和Ninke算法，以及Stucki算法等。通过使用Floyd-Steinberg算法进行误差扩散半色调，可以使得图像在仅使用有限的颜色时，仍然能够呈现出较高的细节和质量。总而言之，光栅和蛇形误差扩散半色调是一种有效的图像处理技术，可以在有限的颜色空间中生成具有高质量细节的图像。接下来，对于每个像素点，根据其当前的RGB值和最近的可用颜色进行比较，找到最匹配的颜色。行百里者，半于九十。
光照模型和面绘制算法---半色调模式和抖动技术
weixin_34411563的博客
11-15 435
2019独角兽企业重金招聘Python工程师标准>>> ...
图像的双击半色调算法
最新发布
03-10
<think>好的，我需要帮助用户了解或实现图像处理中的双击半色调算法。首先，我要确认用户提到的“double click halftone”具体指的是什么。因为“双击半色调”在常规的图像处理资料中并不是一个常见术语，可能是一个术语翻译的问题，或者用户可能指的是某种特定的半色调技术，比如误差扩散、有序抖动等。 首先，我需要检查是否存在“双击半色调”的标准算法。查阅资料发现，可能用户指的是“双模式半色调”（Dual-mode halftoning）或者某种需要用户交互的算法，比如通过两次点击选择参数。但更可能的是术语翻译错误，比如将“Dot Diffusion”（点扩散）误译为“双击”。或者，可能用户指的是某种需要两次处理步骤的半色调方法，比如结合两种不同的半色调技术。 如果找不到直接对应的算法，可能需要从半色调的基础知识入手，解释常见的半色调算法，并尝试推测用户的需求。半色调算法通常用于将连续色调图像转换为二值图像，例如在打印中使用的抖动技术。常见的算法包括有序抖动（Bayer矩阵）、误差扩散法（如Floyd-Steinberg）、点扩散等。 接下来，考虑用户可能的实际需求：他们可能想实现一种交互式的半色调处理，比如在图像处理软件中通过两次点击确定参数，或者需要分两步处理的半色调方法。因此，我需要解释半色调的基本原理，并给出一个可能的实现思路，比如结合两种不同的半色调技术，或者允许用户通过交互调整参数。 在实现部分，可能需要使用Python，结合图像处理库如PIL或OpenCV，演示如何将灰度图像转换为二值图像，使用误差扩散法，并允许用户调整阈值或扩散参数。同时，要确保代码示例正确，并符合用户的要求。 另外，用户提供的引用内容似乎与英语短句相关，可能是一个错误或者不相关的引用，需要忽略这部分，专注于图像处理相关的解释。 最后，生成相关问题，帮助用户进一步探索半色调算法的其他方面，如不同方法的比较、优化或应用场景。 总结步骤： 1. 解释半色调算法的基本概念和应用。 2. 分析用户提到的“双击半色调”可能的含义，并给出合理的推测。 3. 提供一种可能的实现方法，例如基于误差扩散法的交互式调整。 4. 提供Python代码示例。 5. 生成相关问题，引导用户深入学习。</think>### 双击半色调算法解释与实现 #### 1. 半色调算法基础 半色调技术通过二值化处理（黑白点分布）模拟灰度图像的视觉效果，常用于印刷、显示设备等场景。其核心是通过空间分布的黑白点密度变化表现灰度级，例如：$I(x,y) = \begin{cases} 1 & \text{若 } g(x,y) \geq T \\ 0 & \text{否则} \end{cases}$，其中$T$为阈值[^1]。 #### 2. "双击半色调"的推测定义 该术语可能指以下两种实现方式之一： - **交互式参数调整**：通过两次点击确定半色调处理区域或阈值 - **双模式处理**：结合两种半色调算法（如误差扩散+有序抖动） #### 3. 实现示例（交互式误差扩散法） ```python from PIL import Image, ImageDraw import numpy as np def double_click_halftone(image_path, click_pos1, click_pos2): img = Image.open(image_path).convert('L') pixels = np.array(img) # 根据点击位置计算局部阈值 x1, y1 = click_pos1 x2, y2 = click_pos2 local_threshold = (pixels[y1, x1] + pixels[y2, x2]) / 2 # Floyd-Steinberg误差扩散 for y in range(img.height-1): for x in range(1, img.width-1): old_pixel = pixels[y, x] new_pixel = 255 if old_pixel >= local_threshold else 0 pixels[y, x] = new_pixel quant_error = old_pixel - new_pixel # 误差扩散矩阵 pixels[y, x+1] += quant_error * 7/16 pixels[y+1, x-1] += quant_error * 3/16 pixels[y+1, x] += quant_error * 5/16 pixels[y+1, x+1] += quant_error * 1/16 return Image.fromarray(pixels) ``` #### 4. 算法关键参数 $$ T_{dynamic} = \alpha \cdot I(x_1,y_1) + (1-\alpha) \cdot I(x_
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值