图像处理opencv2-Rect <vector>排序、合并

      opencv进行rect检测时，当检测到多个rect，组成rect vector之后，有些rect是由一个区域误分割得到的，可以按照某种规格将这些rect合并为一个rect。比如按照x,y,width,height特性。

     可以先按照x坐标或者y坐标排序。

      

//按照X坐标排序
bool BOCR::rect_rank_x(vector<Rect> &vec_rects) {
	Rect vec_temp;
	for (int l = 1; l < vec_rects.size(); l++) {
		for (int m = vec_rects.size() - 1; m >= l; m--) {
			if (vec_rects[m].x < vec_rects[m - 1].x) {
				vec_temp = vec_rects[m - 1];
				vec_rects[m - 1] = vec_rects[m];
				vec_rects[m] = vec_temp;
			}
		}
	}
	return true;
}
//按照X坐标排序
bool BOCR::rect_rank_y(vector<Rect> &vec_rects) {
	Rect vec_temp;
	for (int l = 1; l < vec_rects.size(); l++) {
		for (int m = vec_rects.size() - 1; m >= l; m--) {
			if (vec_rects[m].y < vec_rects[m - 1].y) {
				vec_temp = vec_rects[m - 1];
				vec_rects[m - 1] = vec_rects[m];
				vec_rects[m] = vec_temp;
			}
		}
	}
	return true;
}


/*将rect上下合并
 * 参数：vec_rects：输入的所有的rect集合；
 *      vec_rects_out:输出的上下合并后的所有的rect集合；
 *      x_dif：进行上下合并的x差值；y_dif：进行上下合并的y差值；
 *      width:进行上下合并的width最大值；height:进行上下合并的height最大值；
 width_rect:合并后的rect的width的值大于width_rect为满足条件
 */
bool BOCR::rect_combine_uplow(vector<Rect> &vec_rects,
		vector<Rect>&vec_rects_out, int x_dif, int y_dif, int width, int height,
		int width_rect) {
	rect_rank_y(vec_rects);
//将上下部分分裂的，合并
	int num_rect = vec_rects.size();
	for (int j = 0; j < num_rect; j++) {
		if (vec_rects[j].width > 0) {
			Rect r;
			for (int p = 0; p < num_rect; p++) {
				if ((vec_rects[p].width > 0) && (p > j || p < j)) {
					if ((((abs(vec_rects[p].x - vec_rects[j].x) < x_dif)
							|| (abs(
									vec_rects[p].x + vec_rects[p].width
											- vec_rects[j].x
											- vec_rects[j].width) < x_dif))
							&& ((abs(
									vec_rects[p].y
											- (vec_rects[j].y
													+ vec_rects[j].height))
									< y_dif)
									|| (abs(
											vec_rects[j].y
													- (vec_rects[p].y
															+ vec_rects[p].height))
											< y_dif))
							&& (vec_rects[p].height < height)
							&& (vec_rects[j].height < height)
							&& (vec_rects[p].width < width)
							&& (vec_rects[j].width < width))) {

						r.x = min(vec_rects[j].x, vec_rects[p].x);
						r.y = min(vec_rects[j].y, vec_rects[p].y);
						r.width = max(
								vec_rects[p].x + vec_rects[p].width
										- vec_rects[j].x,
								vec_rects[j].x + vec_rects[j].width
										- vec_rects[p].x);
						r.height = max(
								vec_rects[j].y + vec_rects[j].height
										- vec_rects[p].y,
								vec_rects[p].y + vec_rects[p].height
										- vec_rects[j].y);
						if (vec_rects[p].y < vec_rects[j].y) {
							vec_rects[p].width = 0;
							vec_rects[p].x = 0;
							vec_rects[p].height = 0;
							vec_rects[p].y = 0;
							vec_rects[j] = r;
						} else {
							vec_rects[j].width = 0;
							vec_rects[j].x = 0;
							vec_rects[j].height = 0;
							vec_rects[j].y = 0;
							vec_rects[p] = r;
						}

					}
				}
			}
		}
	}

	for (int j = 0; j < num_rect; j++) {
		if (vec_rects[j].width > width_rect) {
			vec_rects_out.push_back(vec_rects[j]);
		}
	}
	return true;
}

/*将rect左右合并
 * 参数：
 * show:输入图像；
 * vec_rects：输入的所有的rect集合；
 * vec_rects_out:输出的左右合并后的所有的rect集合；
 * x_dif：进行左右合并的x差值；y_dif：进行左右合并的y差值；
 * width:进行左右合并的width最大值；height:进行左右合并的height最大值；
 * rate1：rect的长宽比最小值1;rate2:rect的长宽比最小值2;
 * width_rect:合并后的rect的width的值大于width_rect为满足条件
 */
bool BOCR::rect_combine_leftright(Mat & show, vector<Rect> &vec_rects,
		vector<Rect>&vec_rects_out, int x_dif, int y_dif, int width, int height,
		double rate1, double rate2, int width_rect) {
	int num = vec_rects.size();
	for (int j = 0; j < num - 1; j++) {
		if (vec_rects[j].width > 0) {
			for (int q = j + 1; q < num; q++) {
				if (vec_rects[q].width > 0) {
					Rect r;
					if ((max(vec_rects[q].x - x_dif, 0)
							< min(vec_rects[j].x + vec_rects[j].width,
									show.cols))
							&& ((abs(vec_rects[q].y - vec_rects[j].y) < y_dif)
									|| (abs(
											min(
													vec_rects[q].y
															+ vec_rects[q].height,
													show.rows)
													- min(
															vec_rects[j].y
																	+ vec_rects[j].height,
															show.rows)) < y_dif))
							&& (vec_rects[q].width < width)
							&& (vec_rects[j].width < width)
							&& (((vec_rects[q].height
									/ (double) vec_rects[q].width > rate1)
									&& (vec_rects[j].height
											/ (double) vec_rects[j].width
											> rate2))
									|| ((vec_rects[j].height
											/ (double) vec_rects[j].width
											> rate1)
											&& (vec_rects[q].height
													/ (double) vec_rects[q].width
													> rate2)))) {
						if ((vec_rects[j].x + vec_rects[j].width
								> show.cols / 10 * 8.5)
								&& (vec_rects[q].x > show.cols / 10 * 8.5)
								&& abs(vec_rects[j].width - vec_rects[q].width)
										< 4
								&& abs(
										vec_rects[j].height
												- vec_rects[q].height) < 3) {
							;
						} else {
							r.x = vec_rects[j].x;
							r.y = min(vec_rects[j].y, vec_rects[q].y);
							r.width = vec_rects[q].x + vec_rects[q].width
									- vec_rects[j].x;
							r.height = max(vec_rects[j].y + vec_rects[j].height,
									vec_rects[q].y + vec_rects[q].height) - r.y;
							vec_rects[q].width = 0;
							vec_rects[q].x = 0;
							vec_rects[j] = r;
						}
					}
				}
			}
		}
	}
	for (int j = 0; j < num; j++) {
		if (vec_rects[j].width > width_rect) {
			vec_rects_out.push_back(vec_rects[j]);
		}
	}
	return true;
}