基于投影和众数特点的粘连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]));    }