字符紧缩对齐

最新推荐文章于 2023-04-03 17:26:27 发布
最新推荐文章于 2023-04-03 17:26:27 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 字符紧缩对齐 文章标签： 字符紧缩对齐
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s12244315/article/details/49720655
版权

     经过归一化处理的字符在图像图像中排列没有规律，这给后续的字符样本提取增加了工作量。因此，这里还要对字符进行缩紧和对齐。

      代码如下：

/****************************************************************
功能：      对目标（如字符）进行缩紧和对齐，归一化之后使用
参数：      img：输入图像
                dst：输出对齐后的图像
				vector<RECT> vecRT：归一化之后所得的 字符分割的矩形框
注    ：      只能处理二值图像
返回值：   返回分割字符的矩形框
***************************************************************/
vector<RECT> Ctry::ObjectAlign(IplImage* src, IplImage* dst, vector<RECT> vecRT)
{
	int nNormW, nNormH;      //归一化之后统一矩形的宽、高
	if (vecRT.size() > 0)
	{
		nNormW = vecRT[0].right - vecRT[0].left + 1;
		nNormH = vecRT[0].bottom - vecRT[0].top + 1;
	}

	int nSrc_i, nSrc_j;   //映射源坐标
	RECT  rt;
	vector<RECT> rtNEW;
	rtNEW.clear();
	rtNEW.resize(vecRT.size());
	int nMargin = 2;   //紧缩对齐后，图像留出左、上边界距离

	//依次调整每个轮廓矩形区域的位置
	for (int nObj = 0; nObj < vecRT.size(); nObj++)
	{
		rt = vecRT[nObj];
		//紧缩对齐后的轮廓矩形
		rtNEW[nObj].left = nObj*nNormW + nMargin;    //左边界
		rtNEW[nObj].right = (nObj + 1)*nNormW + nMargin;
		rtNEW[nObj].top = 0 + nMargin;    //上边界
		rtNEW[nObj].bottom = nNormH + nMargin;

		vecRT[nObj] = rtNEW[nObj];
        //将原矩形框内的像素映射到新的矩形框中
		for (int i = 0; i < nNormH; i++)
		{
			for (int j = nObj*nNormW; j < (nObj + 1)*nNormW; j++)
			{
				//计算映射源坐标
				nSrc_i = rt.top + i;
				nSrc_j = rt.left + j - nObj*nNormW;

				double		pixel = cvGetReal2D(src, nSrc_i, nSrc_j);
				cvSetReal2D(dst, i+nMargin, j+nMargin, pixel);
			}
		}
	}
	return  rtNEW;
}

完整的调用改程序的代码：（ void Ctry::OnTryPath() //消息响应函数，函数从这里开始） 


/****************************************************************
功能：      对前景目标（如字符）进行划分，将各个字符的轮廓矩形返回 
参数：      img：输入等待分割的图像
                int areaThreshold：面积阈值，当分割后的字符小于这个值时，会擦除该字符，用于去除噪音等小区域杂点干扰
注    ：      只能处理二值图像
返回值：   返回分割字符的矩形框
***************************************************************/
vector<RECT> Ctry::ObjectSegment(IplImage* img, int areaThreshold)
{
	vector<RECT> vecRoughRECT;    //粗略对象轮廓的矩形向量数组    
	vector<RECT> vecRECT;                 //精化后对象轮廓的矩形向量数组    
	vector<RECT> vecRECTBig;     //存放精化对象区域中大的的矩形框    
	//清空用来表示每个对象的vector    
	vecRoughRECT.clear();
	vecRECT.clear();
	vecRECTBig.clear();

	int nTop, nBttom;   //整体前景区域的上下边界    
	int nObjCnt = 0;      //对象数目    

	//从上向下扫描，找到整体区域的前景的上边界    
	for (int i = 0; i < img->height; i++)
	{
		for (int j = 0; j < img->width; j++)
		{
			double pixel = cvGetReal2D(img, i, j);
			if (int(pixel) == 0)
			{
				nTop = i;
				i = img->height;   //对i赋大值，使得在break跳出内存循环后，直接在跳出外层循环    
				break;
			}
		}
	}

	//从下向上扫描，找到整体区域的前景的下边界    
	for (int i = img->height - 1; i >= 0; i--)
	{
		for (int j = 0; j < img->width; j++)
		{
			double pixel = cvGetReal2D(img, i, j);
			if (int(pixel) == 0)
			{
				nBttom = i;
				i = -1;   //对i赋小值，使得在break跳出内存循环后，直接在跳出外层循环    
				break;
			}
		}
	}

	bool bStartSeg = false;      //是否已经开始某一个对象的分割    
	bool bBlackInCol;             //某一列中是否包含黑色像素    

	RECT rt;

	//按列扫描，找到每一个目标的左右边界    
	for (int j = 0; j < img->width; j++)
	{
		bBlackInCol = false;
		for (int i = 0; i < img->height; i++)
		{
			double pixel = cvGetReal2D(img, i, j);
			if (int(pixel) == 0)
			{
				bBlackInCol = true;     //该列中发现黑点    
				if (!bStartSeg)  //还没有进入一个对象的分割    
				{
					bStartSeg = true;//进入一个对象的分割    
					rt.left = j;
				}
				else
					break;
			}
		}
		if (j == (img->width - 1))   //扫描到最后一列了，说明整个图像扫描完毕    
		{
			break;
		}
		//正处在分割状态，且扫描完一列都没有发现黑像素，表明当前对象分割完毕    
		if (bStartSeg && !bBlackInCol)
		{
			rt.right = j;     //对象右边界确定    

			//对象的粗略上下边界（有待精化）    
			rt.top = nTop;
			rt.bottom = nBttom;
			::InflateRect(&rt, 1, 1);  //矩形框膨胀一个像素，以免绘制时压到字符    
			vecRoughRECT.push_back(rt);   //插入vector    
			bStartSeg = false;   //当前分割结束    
			nObjCnt++;   //对象数目加1    
		}
	}

	RECT rtNEW;     //存放精化对象区域的矩形框    
	//由于得到了精确的左右边界，现在可以精化矩形框的上下边界    
	int nSize = vecRoughRECT.size();
	for (int nObj = 0; nObj < nSize; nObj++)
	{
		rt = vecRoughRECT[nObj];
		rtNEW.left = rt.left - 1;
		rtNEW.right = rt.right + 1;
		//从上向下逐行扫描边界    
		for (int i = rt.top; i < rt.bottom; i++)
		{
			for (int j = rt.left; j < rt.right; j++)
			{
				double pixel = cvGetReal2D(img, i, j);
				if (int(pixel) == 0)
				{
					rtNEW.top = i - 1;
					//对i赋大值，使得在break跳出内存循环后，直接在跳出外层循环    
					i = rt.bottom;
					break;
				}
			}
		}

		//从下向上逐行扫描边界    
		for (int i = rt.bottom - 1; i > rt.top; i--)
		{
			for (int j = rt.left; j < rt.right; j++)
			{
				double pixel = cvGetReal2D(img, i, j);
				if (int(pixel) == 0)
				{
					rtNEW.bottom = i + 1;
					//对i赋小值，使得在break跳出内存循环后，直接在跳出外层循环    
					i = rt.top - 1;
					break;
				}
			}
		}
		vecRECT.push_back(rtNEW);
	}

	//提取较大的框，擦除小的矩形框  
	for (int i = 0; i < vecRECT.size(); i++)
	{
		int x = vecRECT[i].left;
		int y = vecRECT[i].top;
		int x1 = vecRECT[i].right;
		int y1 = vecRECT[i].bottom;
		int area = (x1 - x)*(y1 - y);   //矩形的面积  
		//当面积小于一个阈值时，擦除当前矩形框中的前景，否则将当前矩形框压入新的vector  
		if (area < areaThreshold)
		{
			for (int i = y; i < y1 + 1; i++)
			{
				for (int j = x; j < x1 + 1; j++)
				{
					cvSetReal2D(img, i, j, 255);
				}
			}
		}
		else
		{
			vecRECTBig.push_back(vecRECT[i]);
		}
	}

	//画矩形框，显示分割字符    
	for (int i = 0; i < vecRECTBig.size(); i++)
	{
		int x = vecRECTBig[i].left - 1;
		int y = vecRECTBig[i].top - 1;
		int x1 = vecRECTBig[i].right + 1;
		int y1 = vecRECTBig[i].bottom + 1;
		CvPoint pt1(x, y);
		CvPoint pt2(x1, y1);
		//cvRectangle(img, pt1, pt2, CV_RGB(255, 0, 0), 1);
	}
	cvSaveImage("C:\\Users\\Administrator\\Desktop\\rect0.jpg", img);	
	return vecRECTBig;
}


void Ctry::OnTryPath()   //消息响应函数，函数从这里开始
{
	// TODO:  在此添加命令处理程序代码    
	IplImage* img = cvLoadImage("C:\\Users\\Administrator\\Desktop\\dst.jpg", -1);

	vector<RECT>  vecRECTBig, vecNew;
	vecRECTBig = ObjectSegment(img, 260);

	IplImage *norm = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
	IplImage *dst1 = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
	for (int i = 0; i < norm->height; i++)
	{
		for (int j = 0; j < norm->width; j++)
		{
			cvSetReal2D(norm, i, j, 255);
			cvSetReal2D(dst1, i, j, 255);
		}
	}

	for (int i = 0; i < vecRECTBig.size(); i++)
	{
		RECT rt = vecRECTBig[i];    //取得一个矩形轮廓
		vecRECTBig[i] = RgnZoom(img, norm, 60, 100, rt);   //将norm图对应的点设为黑色，返回缩放后的矩形框
	}

	vecNew = ObjectAlign(norm, dst1, vecRECTBig);

	for (int i = 0; i < vecRECTBig.size(); i++)
	{
		int x = vecNew[i].left - 1;
		int y = vecNew[i].top - 1;
		int x1 = vecNew[i].right + 1;
		int y1 = vecNew[i].bottom + 1;
		CvPoint pt1(x, y);
		CvPoint pt2(x1, y1);
		cvRectangle(dst1, pt1, pt2, CV_RGB(255, 0, 0), 1);
	}
	cvSaveImage("C:\\Users\\Administrator\\Desktop\\tar.jpg", dst1);
}


/****************************************************************
功能：       字符归一化
参数：        img:有待归一化的图像
                  dst：归一化后目标图像
				  int nTargWidth：归一化的目标宽度
				  int nTargHeight：归一化的目标高度
				  RECT lpRect：等待缩放的矩形框
注    ：       只能处理二值图像
返回值：   缩放后的矩形框
***************************************************************/
RECT  Ctry::RgnZoom(IplImage* img, IplImage* dst, int nTargWidth, int nTargHeight, RECT lpRect)
{
	RECT retRT;   //缩放后的区域矩形
	double dXScale;   //水平方向缩放因子
	double dYScale;   //竖直方法缩放因子

    //确定缩放系数
	dXScale = (double)nTargWidth / (lpRect.right - lpRect.left + 1);
	dYScale = (double)nTargHeight / (lpRect.bottom - lpRect.top + 1);

	int nSrc_i, nSrc_j;   //映射源坐标

	retRT.top = lpRect.top;
	retRT.bottom = retRT.top + nTargHeight;
	retRT.left = lpRect.left;
	retRT.right = retRT.left + nTargWidth;

   //对图像的区域矩形进行逐行扫描，通过像素映射完成缩放
	for (int  i = retRT.top; i < retRT.bottom; i++)
	{
		for (int j = retRT.left; j < retRT.right; j++)
		{
			//计算映射的源坐标（最邻近插值）
			nSrc_i = retRT.top + int((i - retRT.top) / dYScale);
			nSrc_j = retRT.left + int((j - retRT.left) / dXScale);

			//对应像素赋值
			double pixel = cvGetReal2D(img, nSrc_i, nSrc_j);
			cvSetReal2D(dst, i, j, pixel);
		}
	}
	return retRT;
}




/****************************************************************
功能：      对目标（如字符）进行缩紧和对齐，归一化之后使用
参数：      img：输入图像
                dst：输出对齐后的图像
				vector<RECT> vecRT：归一化之后所得的 字符分割的矩形框
注    ：      只能处理二值图像
返回值：   返回分割字符的矩形框
***************************************************************/
vector<RECT> Ctry::ObjectAlign(IplImage* src, IplImage* dst, vector<RECT> vecRT)
{
	int nNormW, nNormH;      //归一化之后统一矩形的宽、高
	if (vecRT.size() > 0)
	{
		nNormW = vecRT[0].right - vecRT[0].left + 1;
		nNormH = vecRT[0].bottom - vecRT[0].top + 1;
	}

	int nSrc_i, nSrc_j;   //映射源坐标
	RECT  rt;
	vector<RECT> rtNEW;
	rtNEW.clear();
	rtNEW.resize(vecRT.size());
	int nMargin = 2;   //紧缩对齐后，图像留出左、上边界距离

	//依次调整每个轮廓矩形区域的位置
	for (int nObj = 0; nObj < vecRT.size(); nObj++)
	{
		rt = vecRT[nObj];
		//紧缩对齐后的轮廓矩形
		rtNEW[nObj].left = nObj*nNormW + nMargin;    //左边界
		rtNEW[nObj].right = (nObj + 1)*nNormW + nMargin;
		rtNEW[nObj].top = 0 + nMargin;    //上边界
		rtNEW[nObj].bottom = nNormH + nMargin;

		vecRT[nObj] = rtNEW[nObj];
        //将原矩形框内的像素映射到新的矩形框中
		for (int i = 0; i < nNormH; i++)
		{
			for (int j = nObj*nNormW; j < (nObj + 1)*nNormW; j++)
			{
				//计算映射源坐标
				nSrc_i = rt.top + i;
				nSrc_j = rt.left + j - nObj*nNormW;

				double		pixel = cvGetReal2D(src, nSrc_i, nSrc_j);
				cvSetReal2D(dst, i+nMargin, j+nMargin, pixel);
			}
		}
	}
	return  rtNEW;
}

原图：效果图：（归一化效果图）

紧缩对齐效果图：



Do it !
关注
专栏目录
latex缩进与对齐_latex 换行后缩进
weixin_26841743的博客
02-17 1万+
且每个条目输 入完毕之后不需要做任何的强迫换行记号,如:\\\\ (换行符)或者 \\par(分段符) Latex可以自动处理四重enumerate嵌套,编号规 则为第一级自然数,第二级......那么, 如何让空格在本行行尾自动换行?有两种方法可以实现: 方法一: 选中文字, 然后点击格式——段落——缩进和间距, 在常 规栏中,选择对齐方式为“左对齐” ......且每个条目输 入完毕之后不需要...
紧缩对齐(#pragma pack(n))专题分析
12-14
对(#pragma pack(n))字节对齐的几种情况进行了讲解。
**给定一个字符串，如果压缩后长度减小，则输出压缩后的结果，例如“qqqaaa”,压缩为'q3a3',长度变小，则输出'q3a3'**
qq_43252073的博客
03-01 369
给定一个字符串，如果压缩后长度减小，则输出压缩后的结果，例如“qqqaaa”,压缩为’q3a3’,长度变小，则输出’q3a3’ 代码如下： def ya_suo(k_str): c = [i for i in k_str] d = [] # 字符个数 n = 1 # 比较值 q = 1 # 循环次数 xh = len(a)-1 # 首次循环索引 sx = 0 cs = xh while xh &amp;amp;amp;g...
字节对齐（强制对齐以及自然对齐）
weixin_34355559的博客
06-17 362
struct {}node; 32为的x86，window下VC下sizeof(node)的值为1，而linux的gcc下值为0； 一、WINDOWS下（VC--其实GCC和其原理基本一样，象这种问题，一般要查具体的编译器设置）字节对齐的规则： 1、一般设置的对齐方式为1，2，4字节对齐方式，VC一般默认为4字节(最大为8字节)。结构的首地址必须是结构内最宽类型的整数倍地址；另外，结构体...
字符串的存储方式
好好学习，天天向上
05-19 1756
字符串的存储方式 顺序存储 紧缩格式 一个字放四个字符=32位二进制 长度=（n/4）-1 非紧缩格式 一个字存放一个字符 链式存储（非顺序存储） 结点大小为1的链串 结点大小为4的链串 模式匹配算法 设字符串s、p，在s中匹配p中的字符串 //pat 一个字符串类 //一个成员指向数组的首地址 //一个成员为字符串的长度 char *p = pat.str;
c语言特殊字符字符串宽度对齐,[转]C语言字节对齐问题详解
weixin_33772892的博客
05-17 922
引言考虑下面的结构体定义：1 typedef struct{2 charc1;3 shorts;4 charc2;5 inti;6 }T_FOO;假设这个结构体的成员在内存中是紧凑排列的，且c1的起始地址是0，则s的地址就是1，c2的地址是3，i的地址是4。现在，我们编写一个简单的程序：1 int main(void){2 T_FOO a;3 printf(...
字节对齐问题探讨
跬步千里，窥叶知秋
01-13 647
引言      考虑下面的结构体定义： 1 typedef struct{ 2 char c1; 3 short s; 4 char c2; 5 int i; 6 }T_FOO;      假设这个结构体的成员在内存中是紧凑排列的，且c1的起始地址是0，则s的地址就是1，c2的地址是3，i的地址是4。      现在，我们编写一个简单的程
C语言字节对齐问题详解
专注于 IOT 物联网的嵌入式研发
01-07 261
转自：https://www.cnblogs.com/clover-toeic/p/3853132.html 为防止原文链接丢失，特地复制一份。若侵权则删。     引言      考虑下面的结构体定义： 1 typedef struct{ 2 char c1; 3 short s; 4 char c2; 5 int i; 6 }T_FOO;      假设这个结构体的成
python字符串的表示和处理函数
热门推荐
皮皮blog
04-12 1万+
python字符串的表示和处理函数
C语言程序设计（第2版）-2期 经验技巧1-2 使程序快速成为“紧缩对齐”格式.pdf
07-12
在C语言程序设计中，"紧缩对齐"格式是一种编程风格，它强调代码的整洁性和易读性，有助于提高程序的可维护性。在某些IDE（集成开发环境）如VC++6.0中，遵循特定的规则可以使代码自动转换为这种格式。以下是关于这个...
Word入门动画教程-字符间距和文字效果.docx
09-27
- “如果定义了文档网格，则对齐网格”：如果已设置了文档网格，此选项可以让文字自动对齐网格。更多关于文档网格的信息，可以参考其他相关教程。 设置完成后，通过“预览”框检查效果，满意后点击“确定”按钮，...
c语言输出占六个字节向右靠齐,C语言字节对齐问题详解
weixin_35470511的博客
05-18 2953
引言考虑下面的结构体定义：html1 typedef struct{2 charc1;3 shorts;4 charc2;5 inti;6 }T_FOO;假设这个结构体的成员在内存中是紧凑排列的，且c1的起始地址是0，则s的地址就是1，c2的地址是3，i的地址是4。linux如今，咱们编写一个简单的程序：面试1 int main(void){2 T_FOO a;3 ...
redis源码解析（二）——SDS（简单动态字符串）
A_BCDEF_的博客
04-03 1036
版本：redis - 5.0.4 参考资料：redis设计与实现 文件：src下的sds.c sds.h 一、基础知识 c语言中，字符串最后需要加一个空字符‘\0’，作为结束标志。sds延续了这种做法，兼容部分c字符串函数。 二进制安全：由于以空字符作结束标志，所以C语言中，字符串里不能包含空字符。为了解决这个问题，sds以处理二进制的方式处理数据。 sds同样用字符数组存储字符串。字符串修改...
spark_3_2_0-master-3.2.3-1.el7.noarch.rpm
09-16
Ambari+Bigtop 一站式编译和部署解决方案 https://gitee.com/tt-bigdata/ambari-env
浙大城市学院在河南2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
第4周玩转案例分析.pdf
09-16
第4周玩转案例分析
基于MATLAB的教室人数统计系统源代码+使用说明，带有丰富的人机交互GUI界面
09-16
基于MATLAB的教室人数统计，带有丰富的人机交互GUI界面。实现教室人数的计数统计，进而统计出勤率，上课认真听讲的比例。原先预设总人数，未出勤或者书本遮住脸部、趴着玩手机等必然无法采集到人脸，从而对应数量缺失，得出出勤率或听讲率。该课题采用肤色原理进行人脸定位和人脸分割。本课题中，为了界面GUI的美观，刻意将分割出的人脸单独显示在GUI对应的axes里
c语言输出字符串对齐
08-17
在 C 语言中，输出字符串对齐通常是通过控制台 I/O 函数 `printf` 或者字符串操作函数如 `puts` 来实现的。如果你想让字符串按照特定的列宽对齐，可以借助格式化字符串中的修饰符。例如： 1. **左对齐** (默认)：如果需要填充空格，你可以使用 `%s` 后跟指定宽度的数字，如 `%-10s` 表示输出一个字符串并在其左边留出10个空格的位置。 ```c char str[] = "Hello"; printf("%-10s", str); // 输出 "Hello " ``` 2. **右对齐**：如果你想将字符串放在指定位置的右侧并用空格填充左边，可以使用 `%5s` 这样的格式，因为 `%-5s` 的 `-` 表示从右边开始计数。 ```c printf("%5s", str); // 输出 " Hello" ``` 3. **居中对齐**：你需要组合使用 `%*s` 和算术运算。假设你想让字符串占据10个字符的总宽度，中间用空格填充： ```c int len = strlen(str); printf("%*s", 10 - len, str); // 如果str长度小于10，会自动填充空格 ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值