package train;

import java.awt.Color;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FilenameFilter;

import java.io.IOException;

import java.util.ArrayList;

import javax.imageio.ImageIO;

import model.Point;

public class SegWaterDrop {

private int minD = 8;//最小字符宽度

private int maxD = 16;

private int meanD = 12;//平均字符宽度

private int b = 1;//大水滴的宽度 2*B+1,取0或者1效果最好

private ArrayList<BufferedImage> imageList;

private BufferedImage sourceImage;

public SegWaterDrop() {

imageList = new ArrayList<BufferedImage>();

}

public static void run(){

try {

File dir = new File("2_cfs");

SegWaterDrop model = new SegWaterDrop();

//只列出jpg

File[] files = dir.listFiles(new FilenameFilter() {

public boolean isJpg(String file){

if (file.toLowerCase().endsWith(".jpg")){

return true;

}else{

return false;

}

}

@Override

public boolean accept(File dir, String name) {

// TODO Auto-generated method stub

return isJpg(name);

}

});

for (File file : files) {

BufferedImage sourceImage = ImageIO.read(file);

ArrayList<BufferedImage> list = model.drop(sourceImage);

for(int j=0; j<list.size(); j++){

BufferedImage subImg = list.get(j);

String prex = file.getName().split("\\.")[0];

String filename = "3_drop/" + prex + "-" + j + ".jpg";

ImageIO.write(subImg, "JPG", new File(filename));

}

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public static void test(){

try {

SegWaterDrop model = new SegWaterDrop();

File file = new File("2_cfs/99-0.jpg");

BufferedImage sourceImage = ImageIO.read(file);

ArrayList<BufferedImage> list = model.drop(sourceImage);

for(int j=0; j<list.size(); j++){

BufferedImage subImg = list.get(j);

String prex = file.getName().split("\\.")[0];

String filename = "3_drop/" + prex + "-" + j + ".jpg";

ImageIO.write(subImg, "JPG", new File(filename));

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

/**

* 滴水法入口

* @param sourceImage

* @return 切割完图片的数组

*/

public ArrayList<BufferedImage> drop(BufferedImage sourceImage){

this.imageList.clear();

this.sourceImage = sourceImage;

int width = sourceImage.getWidth();

int height = sourceImage.getHeight();

// if (width <= maxD) {

// //如果是单个字符，则直接返回

// this.imageList.add(sourceImage);

// return this.imageList;

// }

//在x轴的投影

int[] histData = new int[width];

for (int x = 0; x < width; x++) {

for (int y = 0; y < height; y++) {

if (isBlack(sourceImage.getRGB(x, y))) {

histData[x]++;

}

}

}

ArrayList<Integer> extrems = Extremum.getMinExtrem(histData);

Point[] startRoute = new Point[height];

Point[] endRoute = null;

for(int y=0; y < height; y++){

startRoute[y] = new Point(0, y);

}

int num = (int)Math.round((double)width/meanD);//字符的个数

int lastP = 0; //上一次分割的位置

int curSplit = 1;//分割点的个数，小于等于 num - 1;

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

if (curSplit > num - 1) {

break;

}

//判断两个分割点之间的距离是否合法

int curP = extrems.get(i);

int dBetween = curP - lastP + 1;

if (dBetween < minD || dBetween > maxD) {

continue;

}

// //判断当前分割点与末尾结束点的位置是否合法

// int dAll = width - curP + 1;

// if (dAll < minD*(num - curSplit) || dAll > maxD*(num - curSplit)) {

// continue;

// }

endRoute = getEndRoute(new Point(curP, 0), height, curSplit);

doSplit(startRoute, endRoute);

startRoute = endRoute;

lastP = curP;

curSplit ++;

System.out.println(curP);

}

endRoute = new Point[height];

for(int y=0; y < height; y++){

endRoute[y] = new Point(width - 1, y);

}

doSplit(startRoute, endRoute);

System.out.println("=================");

System.out.println(width+","+height);

return this.imageList;

}

/**

* 获得滴水的路径

* @param startP

* @param height

* @return

*/

private Point[] getEndRoute(Point startP, int height, int curSplit){

//获得分割的路径

Point[] endRoute = new Point[height];

Point curP = new Point(startP.x, startP.y);

Point lastP = curP;

endRoute[0] = curP;

while(curP.y < height - 1){

int maxW = 0;

int sum = 0;

int nextX = curP.x;

int nextY = curP.y;

for (int j = 1; j <= 5; j++) {

try {

int curW = getPixelValue(curP.x, curP.y, j) * (6 - j);

sum += curW;

if (curW > maxW) {

maxW = curW;

}

} catch (Exception e) {

e.printStackTrace();

System.exit(0);

}

}

//如果全黑，需要看惯性

if (sum == 0 ) {

maxW = 4;

}

//如果周围全白，则默认垂直下落

if (sum == 15) {

maxW = 6;

}

switch (maxW) {

case 1:

nextX = curP.x - 1;

nextY = curP.y;

break;

case 2:

nextX = curP.x + 1;

nextY = curP.y;

break;

case 3:

nextX = curP.x + 1;

nextY = curP.y + 1;

break;

case 5:

nextX = curP.x - 1;

nextY = curP.y + 1;

break;

case 6:

nextX = curP.x;

nextY = curP.y + 1;

break;

case 4:

if (nextX > curP.x) {//具有向右的惯性

nextX = curP.x + 1;

nextY = curP.y + 1;

}

if (nextX < curP.x) {//向左的惯性或者sum = 0

nextX = curP.x;

nextY = curP.y + 1;

}

if (sum == 0) {

nextX = curP.x;

nextY = curP.y + 1;

}

break;

default:

break;

}

//如果出现重复运动

if (lastP.x == nextX && lastP.y == nextY) {

if (nextX < curP.x) {//向左重复

maxW = 5;

nextX = curP.x + 1;

nextY = curP.y + 1;

}else{//向右重复

maxW = 3;

nextX = curP.x - 1;

nextY = curP.y + 1;

}

}

lastP = curP;

int rightLimit = meanD*curSplit + 1;

if (nextX > rightLimit) {

nextX = rightLimit;

nextY = curP.y + 1;

}

int leftLimit = meanD*(curSplit - 1) + meanD/2;

if (nextX < leftLimit) {

nextX = leftLimit;

nextY = curP.y + 1;

}

curP = new Point(nextX, nextY);

endRoute[curP.y] = curP;

}

return endRoute;

}

/**

* 具体实行切割

* @param starts

* @param ends

*/

private void doSplit(Point[] starts, Point[] ends){

int left = starts[0].x;

int top = starts[0].y;

int right = ends[0].x;

int bottom = ends[0].y;

for (int i = 0; i < starts.length; i++) {

left = Math.min(starts[i].x, left);

top = Math.min(starts[i].y, top);

right = Math.max(ends[i].x, right);

bottom = Math.max(ends[i].y, bottom);

}

int width = right - left + 1;

int height = bottom - top + 1;

BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);

for (int x = 0; x < width; x++) {

for (int y = 0; y < height; y++) {

image.setRGB(x, y, new Color(255, 255, 255).getRGB());

}

}

for (int i = 0; i < ends.length; i++) {

Point start = starts[i];

Point end = ends[i];

for (int x = start.x; x < end.x; x++) {

if (isBlack(sourceImage.getRGB(x, i))) {

// System.out.println((x - left) + ", " + (start.y - top));

image.setRGB(x - left, start.y - top, new Color(0, 0, 0).getRGB());

}

}

}

this.imageList.add(image);

System.out.println("-----------------------");

}

/**

* 判断是否位黑色像素

* @param rgb

* @return

*/

private boolean isBlack(int rgb) {

Color color = new Color(rgb);

if (color.getRed() + color.getGreen() + color.getBlue() <= 300) {

return true;

}

return false;

}

/**

* 获得大水滴中心点周围的像素值

* @param cx

* @param cy

* @param j 中心点周围的编号

* @return

*/

private int getPixelValue(int cx, int cy, int j){

int rgb = 0;

if (j == 4) {

int right = cx + b + 1;

right = right >= sourceImage.getWidth() - 1 ? sourceImage.getWidth() - 1: right;

rgb = sourceImage.getRGB(right, cy);

return isBlack(rgb) ? 0 : 1;

}

if (j == 5) {

int left = cx - b - 1;

left = left <=0 ? 0 : left;

rgb = sourceImage.getRGB(left, cy);

return isBlack(rgb) ? 0 : 1;

}

//如果 1<= j <= 3, 则判断下方的区域， 只要有一个黑点，则当做黑点，

int start = cx - b + j - 2;

int end = cx + b + j - 2;

start = start <=0 ? 0 : start;

end = end >= sourceImage.getWidth() - 1 ? sourceImage.getWidth() - 1 : end;

int blackNum = 0;

int whiteNum = 0;

for (int i = start; i <= end; i++) {

rgb = sourceImage.getRGB(i, cy + 1);

if (isBlack(rgb)) {

blackNum ++;

}else {

whiteNum ++;

}

}

return (blackNum >= whiteNum) ? 0 : 1;

}

public static void main(String[] args){

SegWaterDrop.run();

}

}