误差扩散法

于 2021-11-22 19:28:41 发布
阅读量3.5k 收藏 5
点赞数 1
分类专栏： 【opencv学习】 文章标签： 算法 计算机视觉 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doubleintfloat/article/details/121478517
版权

https://blog.csdn.net/weixin_34406061/article/details/92425842 代码是C#,我把他改成C++

Floyd-Steinberg抖动算法简直量身为价签这种低颜色呈现设备准备的。由于价签的墨水屏能够呈现的色彩非常有限，根据型号不同，有的只能显示黑白，有的只能显示黑白红，有的只能显示黑白黄，所以对于一张普通图片，需要将其转换为两色或者三色才能比较好地在价签上展示出来。

左边图是主函数调用传入参数1 ， 右边是传入参数3
在这里插入图片描述


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

using namespace cv;
using namespace std;
#define M_COUNT  255
class  RGBTriple
{
public:
	byte* channels;
	int m_size;
	RGBTriple() { channels = new byte[3]; }
	RGBTriple(int R, int G, int B)
	{
		channels = new byte[]{ (byte)R, (byte)G, (byte)B };
	}
};

class BMPConverter
{
public:
	RGBTriple* getPalette(int deviceType)
	{
		RGBTriple* palette = NULL;
		if (deviceType == 0)
		{
			//黑白价签
			palette = new RGBTriple[]{
					RGBTriple(0, 0, 0),
					RGBTriple(255, 255, 255)
			};
			palette->m_size = 2;
		}
		else if (deviceType == 1) {
			//黑白红价签
			palette = new RGBTriple[]{
					 RGBTriple(0, 0, 0),
					 RGBTriple(255, 255, 255),
					 RGBTriple(0, 0,255)
			};
			palette->m_size = 3;
		}
		else if (deviceType == 2) 
		{
			//黑白黄价签
			palette = new RGBTriple[]{
					 RGBTriple(0, 0, 0),
					 RGBTriple(255, 255, 255),
					 RGBTriple(255, 255, 0)
			};
			palette->m_size = 3;
		}
		else if (deviceType == 3)
		{ //RGB
			palette = new RGBTriple[]
			{
					RGBTriple(0 * M_COUNT, 0 * M_COUNT, 0 * M_COUNT),
					RGBTriple(0 * M_COUNT, 0 * M_COUNT, 1 * M_COUNT),
					RGBTriple(0 * M_COUNT, 1 * M_COUNT, 0 * M_COUNT),
					RGBTriple(0 * M_COUNT, 1 * M_COUNT, 1 * M_COUNT),
					RGBTriple(1 * M_COUNT, 0 * M_COUNT, 0 * M_COUNT),
					RGBTriple(1 * M_COUNT, 0 * M_COUNT, 1 * M_COUNT),
					RGBTriple(1 * M_COUNT, 1 * M_COUNT, 0 * M_COUNT),
					RGBTriple(1 * M_COUNT, 1 * M_COUNT, 1 * M_COUNT)			
			};
			palette->m_size = 8;
		}
		return palette;
	};

	void  floydSteinbergDither(Mat  image, RGBTriple palette[])
	{
		//byte result = new byte[image.length][image[0].length];
		Mat result = Mat::zeros(image.rows, image.cols, CV_8UC3);//先生成空的目标图片
	   //result = image;
		uchar* p_img;
		Mat matb, matg, matr, matr_dst, matg_dst, matb_dst;

		uchar* p_img_b;
		uchar* p_img_g;
		uchar* p_img_r;

		uchar* p_img_b_dst;
		uchar* p_img_g_dst;
		uchar* p_img_r_dst;

		uchar* p_lw_b;
		uchar* p_lw_g;
		uchar* p_lw_r;

		//1、先进行通道分解
		Mat planes[3];
		split(image, planes);
		matb = planes[0];
		matg = planes[1];
		matr = planes[2];

		Mat planes_dst[3];
		split(result, planes_dst);
		matb_dst = planes_dst[0];
		matg_dst = planes_dst[1];
		matr_dst = planes_dst[2];


		for (int i = 0; i < image.rows - 2; i++)
		{
			//p_img_b = matb.ptr<uchar>(i);
			//p_img_g = matg.ptr<uchar>(i);
			//p_img_r = matr.ptr<uchar>(i);

			p_img = result.ptr<uchar>(i);

			p_img_b = matb.ptr<uchar>(i);
			p_img_g = matg.ptr<uchar>(i);
			p_img_r = matr.ptr<uchar>(i);

			p_img_b_dst = matb_dst.ptr<uchar>(i);
			p_img_g_dst = matg_dst.ptr<uchar>(i);
			p_img_r_dst = matr_dst.ptr<uchar>(i);

			p_lw_b = matb.ptr<uchar>(i + 1);
			p_lw_g = matg.ptr<uchar>(i + 1);
			p_lw_r = matr.ptr<uchar>(i + 1);

			for (int j = 0; j < image.cols - 2; j++)
			{
				RGBTriple currentPixel;// = (RGBTriple)(matb_dst.ptr<uchar>(x), 1, 1);
				currentPixel.channels[0] = p_img_b[j];
				currentPixel.channels[1] = p_img_g[j];
				currentPixel.channels[2] = p_img_r[j];
				byte index = findNearestColor(currentPixel, palette);
				//p_img[j] = index;
#if 1
				switch (index)
				{
				case 0:
					p_img_b_dst[j] = 0* M_COUNT;
					p_img_g_dst[j] = 0*M_COUNT;
					p_img_r_dst[j] = 0* M_COUNT;
					break;
				case 1:
					p_img_b_dst[j] = 0* M_COUNT;
					p_img_g_dst[j] = 0* M_COUNT;
					p_img_r_dst[j] = 1* M_COUNT;
					break;
				case 2:
					p_img_b_dst[j] = 0* M_COUNT;
					p_img_g_dst[j] = 1* M_COUNT;
					p_img_r_dst[j] = 0* M_COUNT;
					break;
				case 3:
					p_img_b_dst[j] = 0* M_COUNT;
					p_img_g_dst[j] = 1* M_COUNT;
					p_img_r_dst[j] = 1* M_COUNT;
					break;
				case 4:
					p_img_b_dst[j] = 1* M_COUNT;
					p_img_g_dst[j] = 0* M_COUNT;
					p_img_r_dst[j] = 0* M_COUNT;
					break;
				case 5:
					p_img_b_dst[j] = 1* M_COUNT;
					p_img_g_dst[j] = 0* M_COUNT;
					p_img_r_dst[j] = 1* M_COUNT;
					break;
				case 6:
					p_img_b_dst[j] = 1* M_COUNT;
					p_img_g_dst[j] = 1* M_COUNT;
					p_img_r_dst[j] = 0* M_COUNT;
					break;
				case 7:
					p_img_b_dst[j] = 1* M_COUNT;
					p_img_g_dst[j] = 1* M_COUNT;
					p_img_r_dst[j] = 1* M_COUNT;
					break;
				default:
					p_img_b_dst[j] = 1* M_COUNT;
					p_img_g_dst[j] = 1* M_COUNT;
					p_img_r_dst[j] = 1* M_COUNT;
					break;
				}
#endif


				// for (int m = 0; m < 3; m++)
				{
					int error_b = (currentPixel.channels[0] & 0xff) - (palette[index].channels[0] & 0xff);
					int error_g = (currentPixel.channels[1] & 0xff) - (palette[index].channels[1] & 0xff);
					int error_r = (currentPixel.channels[2] & 0xff) - (palette[index].channels[2] & 0xff);

					//planes_dst[i + 0][j + 1] = plus_truncate_uchar(image[y + 0][x + 1].channels[i], (error * 7) >> 4);
#if 0
					p_img_b[j + 1] = plus_truncate_uchar(p_img_b[j + 1], (error_b * 7) >> 4);
					p_img_g[j + 1] = plus_truncate_uchar(p_img_g[j + 1], (error_g * 7) >> 4);
					p_img_r[j + 1] = plus_truncate_uchar(p_img_r[j + 1], (error_r * 7) >> 4);

					p_lw_b[j - 1] = plus_truncate_uchar(p_lw_b[j - 1], (error_b * 3) >> 4);
					p_lw_g[j - 1] = plus_truncate_uchar(p_lw_g[j - 1], (error_g * 3) >> 4);
					p_lw_r[j - 1] = plus_truncate_uchar(p_lw_r[j - 1], (error_r * 3) >> 4);

					p_lw_b[j] = plus_truncate_uchar(p_lw_b[j], (error_b * 5) >> 4);
					p_lw_g[j] = plus_truncate_uchar(p_lw_g[j], (error_g * 5) >> 4);
					p_lw_r[j] = plus_truncate_uchar(p_lw_r[j], (error_r * 5) >> 4);

					p_lw_b[j + 1] = plus_truncate_uchar(p_lw_b[j], (error_b * 1) >> 4);
					p_lw_g[j + 1] = plus_truncate_uchar(p_lw_g[j], (error_g * 1) >> 4);
					p_lw_r[j + 1] = plus_truncate_uchar(p_lw_r[j], (error_r * 1) >> 4);
#endif 

#if 1
					p_img_b[j + 1] = plus_truncate_uchar(p_img_b[j + 1], (error_b * 7) / 16);
					p_img_g[j + 1] = plus_truncate_uchar(p_img_g[j + 1], (error_g * 7) / 16);
					p_img_r[j + 1] = plus_truncate_uchar(p_img_r[j + 1], (error_r * 7) / 16);

					p_lw_b[j - 1] = plus_truncate_uchar(p_lw_b[j - 1], (error_b * 3) / 16);
					p_lw_g[j - 1] = plus_truncate_uchar(p_lw_g[j - 1], (error_g * 3) / 16);
					p_lw_r[j - 1] = plus_truncate_uchar(p_lw_r[j - 1], (error_r * 3) / 16);

					p_lw_b[j] = plus_truncate_uchar(p_lw_b[j], (error_b * 5) / 16);
					p_lw_g[j] = plus_truncate_uchar(p_lw_g[j], (error_g * 5) / 16);
					p_lw_r[j] = plus_truncate_uchar(p_lw_r[j], (error_r * 5) / 16);

					p_lw_b[j + 1] = plus_truncate_uchar(p_lw_b[j + 1], (error_b * 1) / 16);
					p_lw_g[j + 1] = plus_truncate_uchar(p_lw_g[j + 1], (error_g * 1) / 16);
					p_lw_r[j + 1] = plus_truncate_uchar(p_lw_r[j + 1], (error_r * 1) / 16);
#endif 

			}
		}

	}
		merge(planes_dst, 3, result);
		imshow("输出1", result);
		imwrite("E:\\00test001.png", result);
		// cout << result << endl;
		waitKey();
}


	void  floydSteinbergDither_test(Mat  image, RGBTriple palette[])
	{
		Mat result = Mat::zeros(image.rows, image.cols, CV_8UC3);//先生成空的目标图片
		//result = image;

		Mat matr_dst, matg_dst, matb_dst;

		uchar* p_img_b_dst;
		uchar* p_img_g_dst;
		uchar* p_img_r_dst;

		vector<Mat> planes_dst;
		split(result, planes_dst);
		matb_dst = planes_dst[0];
		matg_dst = planes_dst[1];
		matr_dst = planes_dst[2];

		for (int i = 0; i < image.rows - 2; i++)
		{
			p_img_b_dst = matb_dst.ptr<uchar>(i);
			p_img_g_dst = matg_dst.ptr<uchar>(i);
			p_img_r_dst = matr_dst.ptr<uchar>(i);
			for (int j = 0; j < image.cols - 2; j++)
			{
				p_img_b_dst[j] = 255;
				p_img_g_dst[j] = 255;
				p_img_r_dst[j] = 255;
			}
		}
		merge(planes_dst, result);
		imshow("输出1", result);
		//cout << result << endl;
		waitKey();
	}

	byte plus_truncate_uchar(byte a, int b)
	{
		if ((a & 0x80) != 0)
		{
			//cout << "hhh" << endl;
		}
		if ((a & 0xff) + b < 0)
		{
			return 0;
		}
		else if ((a & 0xff) + b > 255)
		{
			return (byte)255;
		}
		else
		{
			return (byte)(a + b);
		}
	}


	byte findNearestColor(RGBTriple color, RGBTriple palette[])
	{
		int minDistanceSquared = 255 * 255 + 255 * 255 + 255 * 255 + 1;
		byte bestIndex = 0;
		for (byte i = 0; i < palette->m_size; i++)
		{
			int Rdiff = (color.channels[0] & 0xff) - (palette[i].channels[0] & 0xff);
			int Gdiff = (color.channels[1] & 0xff) - (palette[i].channels[1] & 0xff);
			int Bdiff = (color.channels[2] & 0xff) - (palette[i].channels[2] & 0xff);
			int distanceSquared = Rdiff * Rdiff + Gdiff * Gdiff + Bdiff * Bdiff;
			if (distanceSquared < minDistanceSquared)
			{
				minDistanceSquared = distanceSquared;
				bestIndex = i;
			}
		}
		return bestIndex;
	}
};


int main()
{
	cout << "hello" << endl;
	//Mat img = imread("E:\\photo\\003.png", 1);
	Mat img = imread("E:\\test.png");
	if (img.empty())
	{
		cout << "读取原图错误！" << endl;
		return false;
	}
	if (img.empty())
	{
		cout << "读取logo错误！" << endl;
	}

	namedWindow("原图");
	//cvResizeWindow("原图", 2245/3 , 3142/3 );
	imshow("原图", img);
	int width = img.cols;//图片宽度
	int height = img.rows;//图片高度
	//Mat dst = Mat::zeros(height, width, CV_8UC1);//先生成空的目标图片

	BMPConverter m;
	RGBTriple* palette = m.getPalette(3);
	m.floydSteinbergDither(img, palette);
	//m.floydSteinbergDither_test(img, palette);

	return 0;
}
越甲八千
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Floyd-Steinberg 抖动误差扩散法-oc
baidu_34010350的博客
06-03 540
Floyd-Steinberg 抖动误差扩散算法 oc
论文研究-Floyd-Steinberg Dithering算法误差扩散非对称性研究 .pdf
08-19
Floyd-Steinberg Dithering算法误差扩散非对称性研究，陈波，熊义可，本文基于离焦投影三维测量原理，结合相移法，分析了Floyd-Steinberg Dithering算法误差扩散非对称性对离焦正弦结构光投影误差的影响。通��
Android 墨水屏黑白红色阶算法和抖动算法,拿过去直接用
qq_31057589的博客
11-08 6864
Android 墨水屏黑白红色阶算法和抖动算法, 拿过去直接用, 有问题直接下面问 色阶法 一张图像，我们可以把它划分为几个大的颜色域，图像上的每个像素点根据颜色跟这几个色域的趋近程度，被划分到这些颜色域中去。这种方法比较适用于颜色不多的图像，例如亮色或者三色的形状或者文字图像。以黑白红三色墨水屏为例，处理图像的时候我们希望把它处理成黑白红三色，因此对于一张图像来说，我们可以把图像的所有颜色划分三个大的颜色区域：黑色区域，白色区域，红色区域。 抖动法 对于那些颜色比较多，或者渐变区域比较多的图像，上面的色阶
基于错误扩散的Floyd-Steinbery抖动算法简单理解
gezi322的专栏
04-09 2546
1. 图像处理中的dithering技术 它是一种欺骗你眼睛，使用有限的色彩让你看到比实际图象更多色彩的显示方式。通过在相邻像素间随机的加入不同的颜色来修饰图象，通常这种方式被用于颜色较少的情况下。 2. 错误扩散（Error diffusion） 将当前像素点的误差传递到附近的像素点 3. Floyd–Steinberg dithering 如图：*表示当前的像素...
【图像处理算法】图像处理之误差扩散（抖动）算法
大熊
09-28 8485
【图像处理算法】图像处理之误差扩散（抖动）算法 一、算法简介 误差扩撒法在数据处理中经常碰到，尤其是用于图像处理中，降低色彩的深度。下面有三张图，【图一】256级（8bit）灰度过度 【图二】将图一转换成16级（8bit）灰度（高4位不变，低4位置0） 【图三】将图一用误差扩散法转换成16级灰度。（256级灰度指共256种灰度值，16级灰度指共16种灰...
数字加网图像处理调频加网抖动算法误差扩散算法C++实现
06-19
基于vs2010的数字加网图像处理算法C++实现代码，包括有序抖动算法：bayers算法、halftone算法；误差扩散算法：Stucki算法、Jarvis算法、Floyd-Steinberg算法。
误差扩散算法
swimmingfish2004的专栏
08-06 4931
误差扩散算法（Error diffusion） Error diffusion is a type of halftoning in which the quantization residual is distributed to neighboring pixels that have not yet been processed. Its main use is to convert a
误差扩散法设计用于惯性约束聚变驱动器的色分离光栅光束采样光栅集成元件
02-13
给出了利用误差扩散法设计的色分离光栅光束采样光栅(CSG-BSG)集成元件编码掩模,模拟计算了经部分相干成像系统后的空间像光强分布,并与理想的集成元件面形进行了比较。结果表明,校正后均方差为7.5%,体积偏差为10.2%。
扩散方程的差分解法
06-23
综上所述，通过有限差分法求解一维扩散方程不仅可以提供有效的数值解，还可以根据不同的需求选择合适的格式，以平衡计算效率和稳定性。通过对差分格式的适定性、相容性、收敛性和稳定性进行细致分析，可以确保数值...
程序_扩散系数数值计算_源码
10-04
压降法是一种常见的实验方法，通过测量在特定条件下的压力变化来推算扩散系数。 这个程序可能包括以下关键知识点： 1. **数值方法**：在计算扩散系数时，可能会用到诸如有限差分、有限元或者蒙特卡洛等数值方法。...
误差扩散算法：将误差扩散算法应用于任何图像。-matlab开发
05-31
此函数是使用 Floyd 和 Steinberg 权重的标准误差扩散算法的实现。
ff.zip_Eink_抖动算法_误差扩散算法
最新发布
09-20
实现图片抖动算法 附带两种算法 Eink显示的基础算法
双线插值C语言 误差扩散 C源码 图形处理源码 图片任意比例缩放
09-02
双线插值C语言 图形处理源码 图片任意比例缩放 这个是点C文件 用在打印机驱动里面实现任意比例缩放 误差扩散 是图形半色调灰度处理图片的算法 做驱动开发的时候自己写的
介绍误差扩散基本知识的PPT
05-01
该PPT介绍了误差扩散的基本原理与应用时所需注意的问题，希望对大家有帮助。
bmp转c数组(误差扩散)
04-26
仅支持24位/16位BMP图片，支持误差扩散算法
图形图像处理－之－误差扩散 上篇
热门推荐
HouSisong的专栏
04-23 1万+
图形图像处理－之－误差扩散 上篇                      HouSisong@GMail.com    2008.04.22  (2010.01.05 文章由2篇变成3篇,对误差扩散的速度和质量作进一步探讨!  代码也有一些更新,容纳到我的图像处理建议框架内,并提供源代码下载!  测试环境也有了变
多核程序设计的相关基础知识----以误差扩散算法为例
weixin_34364135的博客
01-31 147
本文从基础入手，主要阐述基于桌面电脑的多核程序设计的基础知识，包括一些向量化运算，虚拟机算，多线程等的相关知识总结。 一.计算平台的分类 单指令单数据流机器（SISD） 传统的串行计算机，所有指令都是串行。 多指令单数据流机器（MISD） 多个指令流同时对一个数据流进行处理。但是大多数情况下，多个指令流处理多个数据才是更加有效的处...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值