hummingbird
/
java_opencv
Not watched
2
0
Fork 0
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 03645abe2e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '03645abe2e'
${ noResults }
java_opencv/src/main/java/com/acts/opencv/base/CardPlusController.java

448 lines
18 kB
Raw Blame History 

  1. package com.acts.opencv.base;

  2. 

  3. import java.util.ArrayList;

  4. import java.util.Date;

  5. import java.util.List;

  6. import java.util.TreeMap;

  7. 

  8. import javax.servlet.http.HttpServletResponse;

  9. 

  10. import org.apache.commons.lang3.StringUtils;

  11. import org.opencv.core.Core;

  12. import org.opencv.core.Core.MinMaxLocResult;

  13. import org.opencv.core.CvType;

  14. import org.opencv.core.Mat;

  15. import org.opencv.core.MatOfFloat;

  16. import org.opencv.core.MatOfInt;

  17. import org.opencv.core.Point;

  18. import org.opencv.core.Range;

  19. import org.opencv.core.Rect;

  20. import org.opencv.core.Scalar;

  21. import org.opencv.core.Size;

  22. import org.opencv.highgui.Highgui;

  23. import org.opencv.imgproc.Imgproc;

  24. import org.opencv.photo.Photo;

  25. import org.slf4j.Logger;

  26. import org.slf4j.LoggerFactory;

  27. import org.springframework.stereotype.Controller;

  28. import org.springframework.web.bind.annotation.RequestMapping;

  29. 

  30. import com.acts.opencv.common.utils.Constants;

  31. import com.acts.opencv.common.utils.OpenCVUtil;

  32. import com.acts.opencv.common.web.BaseController;

  33. 

  34. 

  35. 

  36. @Controller

  37. @RequestMapping(value = "cardPlus")

  38. public class CardPlusController extends BaseController {

  39. 	private static final Logger logger = LoggerFactory.getLogger(CardPlusController.class);

  40. 

  41. 	/**

  42. 	 * 答题卡识别优化

  43. 	 * 创建者 Songer

  44. 	 * 创建时间	2018年3月23日

  45. 	 */

  46. 	@RequestMapping(value = "answerSheet")

  47. 	public void answerSheet(HttpServletResponse response, String imagefile, Integer binary_thresh,

  48. 			String blue_red_thresh) {

  49. 		System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

  50. 		logger.info("\n 完整答题卡识别");

  51. 

  52. 		String sourcePath = Constants.PATH + imagefile;

  53. 		logger.info("url==============" + sourcePath);

  54. 		Mat sourceMat = Highgui.imread(sourcePath, Highgui.CV_LOAD_IMAGE_COLOR);

  55. 		long t1 = new Date().getTime();

  56. 		String destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk0.png";

  57. 		Highgui.imwrite(destPath, sourceMat);

  58. 		logger.info("原答题卡图片======" + destPath);

  59. 		// 初始图片灰度图

  60. 		Mat sourceMat1 = Highgui.imread(sourcePath, Highgui.CV_LOAD_IMAGE_GRAYSCALE);

  61. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk1.png";

  62. 		Highgui.imwrite(destPath, sourceMat1);

  63. 		logger.info("生成灰度图======" + destPath);

  64. 		// 先膨胀 后腐蚀算法，开运算消除细小杂点

  65. 		Mat element = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(2 * 1 + 1, 2 * 1 + 1));

  66. 		Imgproc.morphologyEx(sourceMat1, sourceMat1, Imgproc.MORPH_OPEN, element);

  67. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk2.png";

  68. 		Highgui.imwrite(destPath, sourceMat1);

  69. 		logger.info("生成膨胀腐蚀后的图======" + destPath);

  70. 

  71. 		// 切割右侧和底部标记位图片

  72. 		Mat rightMark = new Mat(sourceMat1, new Rect(sourceMat1.cols() - 100, 0, 100, sourceMat1.rows()));

  73. 

  74. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk3.png";

  75. 		Highgui.imwrite(destPath, rightMark);

  76. 		logger.info("截取右侧定位点图======" + destPath);

  77. 		// 平滑处理消除噪点毛刺等等

  78. 		Imgproc.GaussianBlur(rightMark, rightMark, new Size(3, 3), 0);

  79. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk4.png";

  80. 		Highgui.imwrite(destPath, rightMark);

  81. 		logger.info("平滑处理后的右侧定位点图======" + destPath);

  82. 

  83. 		// 根据右侧定位获取水平投影，并获取纵向坐标

  84. 		Mat matright = horizontalProjection(rightMark);

  85. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk5.png";

  86. 		Highgui.imwrite(destPath, matright);

  87. 		logger.info("右侧水平投影图======" + destPath);

  88. 		// 获取y坐标点，返回的是横向条状图集合

  89. 		List<Rect> listy = getBlockRect(matright, 1, 0);

  90. 

  91. 		Mat footMark = new Mat(sourceMat1, new Rect(0, sourceMat1.rows() - 150, sourceMat1.cols(), 50));

  92. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk6.png";

  93. 		Highgui.imwrite(destPath, footMark);

  94. 		logger.info("截取底部定位点图======" + destPath);

  95. 

  96. 		Imgproc.GaussianBlur(footMark, footMark, new Size(3, 3), 0);

  97. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk7.png";

  98. 		Highgui.imwrite(destPath, footMark);

  99. 		logger.info("平滑处理后的底部定位点图======" + destPath);

  100. 

  101. 		// 根据底部定位获取垂直投影，并获取横向坐标

  102. 		Mat matbootom = verticalProjection(footMark);

  103. 

  104. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk8.png";

  105. 		Highgui.imwrite(destPath, matbootom);

  106. 		logger.info("底部垂直投影图======" + destPath);

  107. 		// 获取x坐标点，返回的是竖向的柱状图集合

  108. 		List<Rect> listx = getBlockRect(matbootom, 0, 0);

  109. 

  110. 

  111. 

  112. 		// 高阶处理：增加HSV颜色查找，查找红色像素点

  113. 		Mat matRed = findColorbyHSV(sourceMat, 156, 180);

  114. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk9.png";

  115. 		Highgui.imwrite(destPath, matRed);

  116. 		logger.info("HSV找出红色像素点======" + destPath);

  117. 

  118. 		Mat dstNoRed = new Mat(sourceMat1.rows(), sourceMat1.cols(), sourceMat1.type());

  119. 		dstNoRed = OpenCVUtil.dilation(sourceMat1);

  120. 		// Imgproc.threshold(sourceMat1, dstNoRed, 190, 255, Imgproc.THRESH_BINARY);

  121. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk10.png";

  122. 		Highgui.imwrite(destPath, dstNoRed);

  123. 		logger.info("原灰度图的图片======" + destPath);

  124. 

  125. 		Photo.inpaint(dstNoRed, matRed, dstNoRed, 1, Photo.INPAINT_NS);

  126. 		// findBlackColorbyHSV(sourceMat);

  127. 		// for (int i = 0;i<dstNoRed.rows();i++) {

  128. 		// for (int j = 0; j < dstNoRed.cols(); j++) {

  129. 		// if(matRed.get(i, j)[0]==255){//代表识别出的红色区域

  130. 		// dstNoRed.put(i,j,255);

  131. 		// }

  132. 		// }

  133. 		// }

  134. 

  135. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk11.png";

  136. 		Highgui.imwrite(destPath, dstNoRed);

  137. 		logger.info("去除红颜色后的图片======" + destPath);

  138. 

  139. 		Mat grayHistogram1 = getGrayHistogram(dstNoRed);

  140. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk12.png";

  141. 		Highgui.imwrite(destPath, grayHistogram1);

  142. 		logger.info("灰度直方图图片1======" + destPath);

  143. 

  144. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk13.png";

  145. 		Mat answerMat = dstNoRed.submat(new Rect(41, 895, 278, 133));

  146. 		Mat grayHistogram2 = getGrayHistogram(answerMat);

  147. 		Highgui.imwrite(destPath, grayHistogram2);

  148. 		logger.info("灰度直方图图片2======" + destPath);

  149. 

  150. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk14.png";

  151. 		Imgproc.threshold(dstNoRed, dstNoRed, binary_thresh, 255, Imgproc.THRESH_BINARY_INV);

  152. 		Highgui.imwrite(destPath, dstNoRed);

  153. 		logger.info("去除红色基础上进行二值化======" + destPath);

  154. 		String redvalue = StringUtils.split(blue_red_thresh, ",")[0];

  155. 		String bluevalue = StringUtils.split(blue_red_thresh, ",")[1];

  156. 		System.out.println(bluevalue + "			" + redvalue);

  157. 		TreeMap<Integer, String> resultMap = new TreeMap<Integer, String>();

  158. 		StringBuffer resultValue = new StringBuffer();

  159. 		for (int no = 0; no < listx.size(); no++) {

  160. 			Rect rectx = listx.get(no);

  161. 			for (int an = 0; an < listy.size(); an++) {

  162. 				Rect recty = listy.get(an);

  163. 				Mat selectdst = new Mat(dstNoRed, new Range(recty.y, recty.y + recty.height), new Range(rectx.x,

  164. 						rectx.x

  165. 						+ rectx.width));

  166. 				// 本来是在每个区域内进行二值化，后来挪至了14步，整体进行二值化，因此注释掉此处2行

  167. 				// Mat selectdst = new Mat(select.rows(), select.cols(), select.type());

  168. 				// Imgproc.threshold(select, selectdst, 170, 255, Imgproc.THRESH_BINARY);

  169. 

  170. 				// System.out.println("rectx.x, recty.y=="+rectx.x+","+recty.y+"rectx.width,recty.height=="+rectx.width+","+recty.height);

  171. 				double p100 = Core.countNonZero(selectdst) * 100 / (selectdst.size().area());

  172. 				String que_answer = getQA(no, an);

  173. 				Integer que = Integer.valueOf(que_answer.split("_")[0]);

  174. 				String answer = que_answer.split("_")[1];

  175. 				// System.out.println(Core.countNonZero(selectdst) + "/" + selectdst.size().area());

  176. 				System.out.println(que_answer + ":			" + p100);

  177. 

  178. 				if (p100 >= Integer.valueOf(bluevalue)) {// 蓝色

  179. 					Core.rectangle(sourceMat, new Point(rectx.x, recty.y), new Point(rectx.x + rectx.width, recty.y

  180. 							+ recty.height), new Scalar(255, 0, 0), 2);

  181. 					// logger.info(que_answer + ":填涂");

  182. 					if (StringUtils.isNotEmpty(resultMap.get(que))) {

  183. 						resultMap.put(que, resultMap.get(que) + "," + answer);

  184. 					} else {

  185. 						resultMap.put(que, answer);

  186. 					}

  187. 				} else if (p100 > Integer.valueOf(redvalue) && p100 < Integer.valueOf(bluevalue)) {// 红色

  188. 					Core.rectangle(sourceMat, new Point(rectx.x, recty.y), new Point(rectx.x + rectx.width, recty.y

  189. 							+ recty.height), new Scalar(0, 0, 255), 2);

  190. 					// logger.info(que_answer + ":临界");

  191. 					if (StringUtils.isNotEmpty(resultMap.get(que))) {

  192. 						resultMap.put(que, resultMap.get(que) + ",(" + answer + ")");

  193. 					} else {

  194. 						resultMap.put(que, "(" + answer + ")");

  195. 					}

  196. 				} else {// 绿色

  197. 					Core.rectangle(sourceMat, new Point(rectx.x, recty.y), new Point(rectx.x + rectx.width, recty.y

  198. 							+ recty.height), new Scalar(0, 255, 0), 1);

  199. 					// logger.info(que_answer + ":未涂");

  200. 				}

  201. 			}

  202. 		}

  203. 

  204. 		// for (Object result : resultMap.keySet()) {

  205. 		for (int i = 1; i <= 100; i++) {

  206. 			// logger.info("key=" + result + " value=" + resultMap.get(result));

  207. 			resultValue.append("  " + i + "=" + (StringUtils.isEmpty(resultMap.get(i)) ? "未填写" : resultMap.get(i)));

  208. 			if (i % 5 == 0) {

  209. 				resultValue.append("<br>");

  210. 			}

  211. 		}

  212. 		destPath = Constants.PATH + Constants.DEST_IMAGE_PATH + "dtk15.png";

  213. 		Highgui.imwrite(destPath, sourceMat);

  214. 		logger.info("框选填图区域，绿色为选项，蓝色为填图，红色为临界======" + destPath);

  215. 		long t2 = new Date().getTime();

  216. 		System.out.println(t2 - t1);

  217. 

  218. 		// logger.info("输出最终结果：" + resultValue.toString());

  219. 

  220. 		renderString(response, resultValue.toString());

  221. 	}

  222. 

  223. 	/**

  224. 	 * 绘制灰度直方图用于调整识别区域阈值判断

  225. 	 * @Author 王嵩

  226. 	 * @param 输入Mat对象img

  227. 	 * @return Mat

  228. 	 * @Date 2018年3月28日

  229. 	 * 更新日志

  230. 	 * 2018年3月28日 王嵩  首次创建

  231. 	 *

  232. 	 */

  233. 	public Mat getGrayHistogram(Mat img) {

  234. 		List<Mat> images = new ArrayList<Mat>();

  235. 		images.add(img);

  236. 		MatOfInt channels = new MatOfInt(0); // 图像通道数，0表示只有一个通道

  237. 		MatOfInt histSize = new MatOfInt(256); // CV_8U类型的图片范围是0~255，共有256个灰度级

  238. 		Mat histogramOfGray = new Mat(); // 输出直方图结果，共有256行，行数的相当于对应灰度值，每一行的值相当于该灰度值所占比例

  239. 		MatOfFloat histRange = new MatOfFloat(0, 255);

  240. 		Imgproc.calcHist(images, channels, new Mat(), histogramOfGray, histSize, histRange, false); // 计算直方图

  241. 		MinMaxLocResult minmaxLoc = Core.minMaxLoc(histogramOfGray);

  242. 		// 按行归一化

  243. 		// Core.normalize(histogramOfGray, histogramOfGray, 0, histogramOfGray.rows(), Core.NORM_MINMAX, -1, new Mat());

  244. 

  245. 		// 创建画布

  246. 		int histImgRows = 600;

  247. 		int histImgCols = 1300;

  248. 		System.out.println("---------" + histSize.get(0, 0)[0]);

  249. 		int colStep = (int) Math.floor(histImgCols / histSize.get(0, 0)[0]);// 舍去小数，不能四舍五入，有可能列宽不够

  250. 		Mat histImg = new Mat(histImgRows, histImgCols, CvType.CV_8UC3, new Scalar(255, 255, 255)); // 重新建一张图片，绘制直方图

  251. 

  252. 

  253. 		int max = (int) minmaxLoc.maxVal;

  254. 		System.out.println("--------" + max);

  255. 		double bin_u = (double) (histImgRows - 20) / max; // max: 最高条的像素个数，则 bin_u 为单个像素的高度，因为画直方图的时候上移了20像素，要减去

  256. 		int kedu = 0;

  257. 		for (int i = 1; kedu <= minmaxLoc.maxVal; i++) {

  258. 			kedu = i * max / 10;

  259. 			// 在图像中显示文本字符串

  260. 			Core.putText(histImg, kedu + "", new Point(0, histImgRows - kedu * bin_u), 1, 1, new Scalar(0, 0, 0));

  261. 		}

  262. 

  263. 

  264. 		for (int i = 0; i < histSize.get(0, 0)[0]; i++) { // 画出每一个灰度级分量的比例，注意OpenCV将Mat最左上角的点作为坐标原点

  265. 			// System.out.println(i + ":=====" + histogramOfGray.get(i, 0)[0]);

  266. 			Core.rectangle(histImg, new Point(colStep * i, histImgRows - 20), new Point(colStep * (i + 1), histImgRows

  267. 					- bin_u * Math.round(histogramOfGray.get(i, 0)[0]) - 20),

  268. 					new Scalar(0, 0, 0), 1, 8, 0);

  269. 			kedu = i * 10;

  270. 			// 每隔10画一下刻度

  271. 			Core.rectangle(histImg, new Point(colStep * kedu, histImgRows - 20), new Point(colStep * (kedu + 1),

  272. 					histImgRows - 20), new Scalar(255, 0, 0), 2, 8, 0);

  273. 			Core.putText(histImg, kedu + "", new Point(colStep * kedu, histImgRows - 5), 1, 1, new Scalar(255, 0, 0)); // 附上x轴刻度

  274. 		}

  275. 

  276. 		return histImg;

  277. 

  278. 	}

  279. 

  280. 	// 获取题号及选项填涂情况

  281. 	public String getQA(int no,int an){

  282. 		//返回1A、1B、1C...2A类似这样的返回值

  283. 		int first = no + 1 + an / 4 * 20;

  284. 		String second = "";

  285. 		if (an % 4 == 0) {

  286. 			second = "A";

  287. 		} else if (an % 4 == 1) {

  288. 			second = "B";

  289. 		} else if (an % 4 == 2) {

  290. 			second = "C";

  291. 		} else if (an % 4 == 3) {

  292. 			second = "D";

  293. 		}

  294. 		return first + "_" + second;

  295. 	}

  296. 

  297. 	public static void main(String[] args) {

  298. 		System.out.println(5 / 3);

  299. 	}

  300. 	/**

  301. 	 * 红色色系0-20，160-180

  302. 	 * 蓝色色系100-120

  303. 	 * 绿色色系60-80

  304. 	 * 黄色色系23-38

  305. 	 * 识别出的颜色会标记为白色，其他的为黑色

  306. 	 * @param min

  307. 	 * @param max

  308. 	 */

  309. 	public static Mat findColorbyHSV(Mat source, int min, int max) {

  310. 		Mat hsv_image = new Mat();

  311. 		Imgproc.GaussianBlur(source, source, new Size(3, 3), 0, 0);

  312. 		Imgproc.cvtColor(source, hsv_image, Imgproc.COLOR_BGR2HSV);

  313. 		// String imagenameb = "D:\\test\\testImge\\ttbefore.jpg";

  314. 		// Highgui.imwrite(imagenameb, hsv_image);

  315. 		Mat thresholded = new Mat();

  316. 		Core.inRange(hsv_image, new Scalar(min, 90, 90), new Scalar(max, 255, 255), thresholded);

  317. 		return thresholded;

  318. 	}

  319. 

  320. 	/**

  321. 	 * 查找黑色

  322. 	 * @param source

  323. 	 * @param min

  324. 	 * @param max

  325. 	 * @return

  326. 	 */

  327. 	public static Mat findBlackColorbyHSV(Mat source) {

  328. 		Mat hsv_image = new Mat();

  329. 		Imgproc.GaussianBlur(source, source, new Size(3, 3), 0, 0);

  330. 		Imgproc.cvtColor(source, hsv_image, Imgproc.COLOR_BGR2HSV);

  331. 		String imagenameb = "D:\\test\\testImge\\ttbefore.jpg";

  332. 		Highgui.imwrite(imagenameb, hsv_image);

  333. 		Mat thresholded = new Mat();

  334. 		Core.inRange(hsv_image, new Scalar(0, 0, 0), new Scalar(180, 255, 46), thresholded);

  335. 		String ttblack = "D:\\test\\testImge\\ttblack.jpg";

  336. 		Highgui.imwrite(ttblack, thresholded);

  337. 		return thresholded;

  338. 	}

  339. 

  340. 	/**

  341. 	 * 水平投影

  342. 	 * @param source 传入灰度图片Mat

  343. 	 * @return

  344. 	 */

  345. 	public static Mat horizontalProjection(Mat source) {

  346. 		Mat dst = new Mat(source.rows(), source.cols(), source.type());

  347. 		// 先进行反转二值化

  348. 		Imgproc.threshold(source, dst, 150, 255, Imgproc.THRESH_BINARY_INV);

  349. 		// 水平积分投影

  350. 		// 每一行的白色像素的个数

  351. 		int[] rowswidth = new int[dst.rows()];

  352. 		for (int i = 0; i < dst.rows(); i++) {

  353. 			for (int j = 0; j < dst.cols(); j++) {

  354. 				if (dst.get(i, j)[0] == 255) {

  355. 					rowswidth[i]++;

  356. 				}

  357. 			}

  358. 		}

  359. 		// 定义一个白色跟原图一样大小的画布

  360. 		Mat matResult = new Mat(dst.rows(), dst.cols(), CvType.CV_8UC1, new Scalar(255, 255, 255));

  361. 		// 将每一行按照行像素值大小填充像素宽度

  362. 		for (int i = 0; i < matResult.rows(); i++) {

  363. 			for (int j = 0; j < rowswidth[i]; j++) {

  364. 				matResult.put(i, j, 0);

  365. 			}

  366. 		}

  367. 		return matResult;

  368. 	}

  369. 

  370. 	/**

  371. 	 * 垂直投影

  372. 	 * @param source 传入灰度图片Mat

  373. 	 * @return

  374. 	 */

  375. 	public static Mat verticalProjection(Mat source) {

  376. 		// 先进行反转二值化

  377. 		Mat dst = new Mat(source.rows(), source.cols(), source.type());

  378. 		Imgproc.threshold(source, dst, 150, 255, Imgproc.THRESH_BINARY_INV);

  379. 		// 垂直积分投影

  380. 		// 每一列的白色像素的个数

  381. 		int[] colswidth = new int[dst.cols()];

  382. 		for (int j = 0; j < dst.cols(); j++) {

  383. 			for (int i = 0; i < dst.rows(); i++) {

  384. 				if (dst.get(i, j)[0] == 255) {

  385. 					colswidth[j]++;

  386. 				}

  387. 			}

  388. 		}

  389. 		Mat matResult = new Mat(dst.rows(), dst.cols(), CvType.CV_8UC1, new Scalar(255, 255, 255));

  390. 		// 将每一列按照列像素值大小填充像素宽度

  391. 		for (int j = 0; j < matResult.cols(); j++) {

  392. 			for (int i = 0; i < colswidth[j]; i++) {

  393. 				matResult.put(matResult.rows() - 1 - i, j, 0);

  394. 			}

  395. 		}

  396. 		return matResult;

  397. 	}

  398. 

  399. 	/**

  400. 	 * 图片切块

  401. 	 * @param srcMat 传入水平或垂直投影的图片对象Mat

  402. 	 * @param proType 传入投影Mat对象的 投影方式0：垂直投影图片,竖向切割；1：水平投影图片，横向切割

  403. 	 * @param rowY 由于传来的是原始图片的部分切片，要计算切块的实际坐标位置需要给出切片时所在的坐标，所以需要传递横向切片的y坐标或者纵向切片的横坐标

  404. 	 * 如当proType==0时，传入的是切片的垂直投影，那么切成块后能得出x坐标及块宽高度，但是实际y坐标需要加上原切片的y坐标值，所以rowXY为切片的y坐标点，

  405. 	 * 同理当proType==1时，rowXY应该为x坐标

  406. 	 * @return

  407. 	 */

  408. 	public static List<Rect> getBlockRect(Mat srcImg, Integer proType, int rowXY) {

  409. 		Imgproc.threshold(srcImg, srcImg, 150, 255, Imgproc.THRESH_BINARY_INV);

  410. 		// 注意 countNonZero 方法是获取非0像素（白色像素）数量，所以一般要对图像进行二值化反转

  411. 		List<Rect> rectList = new ArrayList<Rect>();

  412. 		int size = proType == 0 ? srcImg.cols() : srcImg.rows();

  413. 		int[] pixNum = new int[size];

  414. 		if (proType == 0) {

  415. 			for (int i = 0; i < srcImg.cols(); i++) {

  416. 				Mat col = srcImg.col(i);

  417. 				pixNum[i] = Core.countNonZero(col) > 1 ? Core.countNonZero(col) : 0;

  418. 			}

  419. 		} else {// 水平投影只关注行

  420. 			for (int i = 0; i < srcImg.rows(); i++) {

  421. 				Mat row = srcImg.row(i);

  422. 				pixNum[i] = Core.countNonZero(row) > 1 ? Core.countNonZero(row) : 0;

  423. 			}

  424. 		}

  425. 		int startIndex = 0;// 记录进入字符区的索引

  426. 		int endIndex = 0;// 记录进入空白区域的索引

  427. 		boolean inBlock = false;// 是否遍历到了字符区内

  428. 		for (int i = 0; i < size; i++) {

  429. 			if (!inBlock && pixNum[i] != 0) {// 进入字符区，上升跳变沿

  430. 				inBlock = true;

  431. 				startIndex = i;

  432. 			} else if (pixNum[i] == 0 && inBlock) {// 进入空白区，下降跳变沿存储

  433. 				endIndex = i;

  434. 				inBlock = false;

  435. 				Rect rect = null;

  436. 				if (proType == 0) {

  437. 					rect = new Rect(startIndex, rowXY, (endIndex - startIndex), srcImg.rows());

  438. 				} else {

  439. 					rect = new Rect(rowXY, startIndex, srcImg.cols(), (endIndex - startIndex));

  440. 				}

  441. 				rectList.add(rect);

  442. 			}

  443. 		}

  444. 		return rectList;

  445. 	}

  446. 

  447. }