基于投影和众数特点的粘连sku分割

首先是基本的投影：

/**
* 图像向x轴做投影后的数组
*
* @param imagedata
* @param w
*            宽
* @param h
*            高
* @return
*/
public static int[] xpro(BitSet bitSet, int width, int height) {
int xpro[] = new int[width];
for (int j = 0; j < width; j++) {
for (int i = 0; i < height; i++) {
if (bitSet.get(i * width + j) == true)
xpro[j]++;
}
}
return xpro;
}

public static int[] xpro(ImageData image) {
return xpro(image.getBitSet(), image.getWidth(), image.getHeight());
}

/**
* 图像向y轴做投影后的数组
*
* @param imagedata
* @param w
* @param h
* @return
*/
public static int[] ypro(BitSet bitSet, int width, int height) {
int ypro[] = new int[height];
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
if (bitSet.get(i * width + j) == true)
ypro[i]++;
}
}
return ypro;
}

public static int[] ypro(ImageData image) {
return ypro(image.getBitSet(), image.getWidth(), image.getHeight());
}

然后是基于基本投影的图像分割（割线集合可以用容器，这里不改了）：

public static Rectangle[] yproSegment(int[] ypro, int width, int height) {

int[] L = new int[height - 1];// 左割线集合，最多n-1条分割线，且左分割第一项取0，即图片第一行做起点（需要a行位置没有太多空白噪声）
int[] R = new int[height - 1];// 右割线集合
// 两种情况：sku区域起始位置元素为空白区域；起始位置含字符元素
int k1 = 0;
int k2 = 0;
if (ypro[0] != 0) {
k1 = 1;
L[0] = 0;
}
for (int i = 4; i < height; i++) {
if (ypro[i] > 0 && ypro[i - 1] > 0 && ypro[i - 2] > 0
&& ypro[i - 3] > 0 && ypro[i - 4] == 0) {
L[k1] = i - 4;
k1++;
} else if (ypro[i] == 0 && ypro[i - 1] > 0 && ypro[i - 2] > 0
&& ypro[i - 3] > 0 && ypro[i - 4] > 0) {
R[k2] = i;
k2 += 1;
}
}

if (ypro[ypro.length - 1] != 0) {
R[k2] = height;
}
List<Rectangle> c = new ArrayList<Rectangle>();
for (int i = 0; i < R.length; i++) {
if (R[i] != 0 && L[i] < R[i]) {
c.add(new Rectangle(0, L[i], width, R[i] - L[i]));
} else {
break;
}
}
Rectangle[] children = new Rectangle[c.size()];
for (int i = 0; i < children.length; i++) {
children[i] = c.get(i);
}
return children;
}

但是有时候图像的sku是粘连的，可以利用图像中sku的特点（每行的宽度相似，比较规范，那么只要不是超过50%粘连，众数就必定是区分的合理阈值，再利用极值点作为分割点，以及众数作为校验参数）

/**
* 纵向自动版面分析（众数参考分析）
*
* @param ypro
* @param im
* @param h
* @param w
* @return
*/
public static int[] ylinelayout(int[] ypro, int width, int height) {
// 投影分割图片
boolean flag = false;
for (int i : ypro) {
if (i == 0) {
flag = true;
break;
}
}
if (flag == false) {
int[] result = { 0, ypro.length };
return result;
}
int[] L = new int[height - 1];// 左割线集合，最多n-1条分割线，且左分割第一项取0，即图片第一行做起点（需要a行位置没有太多空白噪声）
int[] R = new int[height - 1];// 右割线集合
// 两种情况：sku区域起始位置元素为空白区域；起始位置含字符元素
int k1 = 0;
int k2 = 0;
if (ypro[0] != 0) {
k1 = 1;
L[0] = 0;
}
for (int i = 4; i < height; i++) {
if (ypro[i] > 0 && ypro[i - 1] > 0 && ypro[i - 2] > 0
&& ypro[i - 3] > 0 && ypro[i - 4] == 0) {//左边界特征
L[k1] = i - 4;
k1++;
} else if (ypro[i] == 0 && ypro[i - 1] > 0 && ypro[i - 2] > 0
&& ypro[i - 3] > 0 && ypro[i - 4] > 0) {//右边界特征
R[k2] = i;
k2 += 1;
}
}
if (ypro[ypro.length - 1] != 0) {
R[k2 + 1] = ypro.length - 1;
}

ArrayList<Integer> c = new ArrayList<Integer>();
for (int i = 0; i < R.length; i++) {
if (R[i] != 0 && L[i] < R[i]) {
c.add(L[i]);
c.add(R[i]);
} else {
break;
}
}

int[] gap = new int[c.size() / 2];// 间隙
for (int i = 0; i < gap.length; i++) {
gap[i] = c.get(i * 2 + 1) - c.get(i * 2);
}
// 得到初次分割的所有“字符”的高度
if (gap.length == 1) {
int[] result = { L[0], R[0] };
return result;
}
if (gap.length == 2) {
int[] result = { L[0], R[0], L[1], R[1] };
return result;
}
int Te = (int) (catchE(gap) + 0.5);
ArrayList<Integer> newc = new ArrayList<Integer>();
for (int i = 0; i < gap.length; i++) {
if (gap[i] >= (int) (Te * 1.5 + 0.5)) {
// 对异常gap进行二次分割（粘连字符二次分割函数）
log.info("发现异常点：" + gap[i]);
int[] newline = improveSegment(c.get(i * 2), c.get(i * 2 + 1),
ypro, gap[i], Te);

if (newline != null) {
for (int j : newline) {
newc.add(j);
log.info("newline:" + j);
}
}
}
}
int begin = 0;
ArrayList<Integer> allline = new ArrayList<Integer>();
allline.addAll(c);
int time = 0;
for (int i = 0; i < newc.size(); i++) {
int th = newc.get(i);
for (int j = begin; j < c.size() - 1; j++) {
if (c.get(j) < th && c.get(j + 1) > th) {
allline.add(j + 1 + time * 2, th);
allline.add(j + 2 + time * 2, th + 1);
begin = j;
time++;
break;
}
}
}
return ArrayUtils.toPrimitive(allline.toArray(new Integer[0]));
}

众数查找：

/**
* 找出众数范围（无补偿众数）
*
* @param gap
* @return
*/
public static float catchE(int[] gap) {

float Te = 0;
int[] g = gap.clone();
Arrays.sort(g);
int[] times = new int[g.length];
for (int i = 0; i < gap.length; i++) {
for (int j = 0; j < g.length; j++) {
if (g[j] == gap[i]) {
times[j]++;
}
}
}
// 得到各gap的出现次数
int tt = 0;
int num = 0;
for (int i = 0; i < times.length; i++) {
if (times[i] > tt) {
tt = times[i];
num = i;
}
}
Te = g[num];
return Te;
}

极值点查找

/**
* 二次分割（找到粘连中的k个线，k》=2）
*
* @param localypro
* @param begin
* @param t1
* @return
*/
public static int findline(int[] localypro, int begin, int t1) {
int findline = 0;
int len = localypro.length - t1;
for (int i = begin; i < len; i++) {
int kL = 0;
int kR = 0;
for (int j = 1; j < t1; j++) {
if (localypro[i] <= localypro[i - j]) {
kL++;
} else {
break;
}
if (localypro[i] <= localypro[i + j]) {
kR++;
} else {
break;
}
}
if (kL == t1 - 1 && kR == t1 - 1) {
findline = i;
break;
}
}
return findline;
}

/**
* 二次分割
*
* @param a
* @param b
* @param ypro
* @param gapE
* @param Te
* @return
*/
public static int[] improveSegment(int a, int b, int[] ypro, float gapE,
int Te) {
if (Te <= 8)
return null;
int[] localypro = Arrays.copyOfRange(ypro, a, b + 1);
// 以t2作为跃迁步长，避免同一区域出现多条分割线，以t1作为分割线阈值，以找到精确分割线
ArrayList<Integer> c = new ArrayList<Integer>();
int t1 = Te - 8;
int t2 = Te - 5;
for (int i = t2; i < localypro.length - t2; i = i + t2) {
int findline = findline(localypro, i, t1);
c.add(a + findline);

}
return ArrayUtils.toPrimitive(c.toArray(new Integer[0]));
}