import javax.net.ssl.SSLSocketFactory;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.UUID;

public class HttpTest {

    private static final String SPLIT = "\r\n";

    private static final String RAW_BODY = """
            豫章故郡，洪都新府。星分翼轸，地接衡庐。襟三江而带五湖，控蛮荆而引瓯越。物华天宝，龙光射牛斗之墟；人杰地灵，徐孺下陈蕃之榻。雄州雾列，俊采星驰。台隍枕夷夏之交，宾主尽东南之美。都督阎公之雅望，棨戟遥临；宇文新州之懿范，襜帷暂驻。十旬休假，胜友如云；千里逢迎，高朋满座。腾蛟起凤，孟学士之词宗；紫电青霜，王将军之武库。家君作宰，路出名区；童子何知，躬逢胜饯。
            时维九月，序属三秋。潦水尽而寒潭清，烟光凝而暮山紫。俨骖騑于上路，访风景于崇阿；临帝子之长洲，得天人之旧馆。层峦耸翠，上出重霄；飞阁流丹，下临无地。鹤汀凫渚，穷岛屿之萦回；桂殿兰宫，即冈峦之体势。
            披绣闼，俯雕甍，山原旷其盈视，川泽纡其骇瞩。闾阎扑地，钟鸣鼎食之家；舸舰弥津，青雀黄龙之舳。云销雨霁，彩彻区明。落霞与孤鹜齐飞，秋水共长天一色。渔舟唱晚，响穷彭蠡之滨；雁阵惊寒，声断衡阳之浦。
            遥襟甫畅，逸兴遄飞。爽籁发而清风生，纤歌凝而白云遏。睢园绿竹，气凌彭泽之樽；邺水朱华，光照临川之笔。四美具，二难并。穷睇眄于中天，极娱游于暇日。天高地迥，觉宇宙之无穷；兴尽悲来，识盈虚之有数。望长安于日下，目吴会于云间。地势极而南溟深，天柱高而北辰远。关山难越，谁悲失路之人？萍水相逢，尽是他乡之客。怀帝阍而不见，奉宣室以何年？
            嗟乎！时运不齐，命途多舛。冯唐易老，李广难封。屈贾谊于长沙，非无圣主；窜梁鸿于海曲，岂乏明时？所赖君子见机，达人知命。老当益壮，宁移白首之心？穷且益坚，不坠青云之志。酌贪泉而觉爽，处涸辙以犹欢。北海虽赊，扶摇可接；东隅已逝，桑榆非晚。孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！
            勃，三尺微命，一介书生。无路请缨，等终军之弱冠；有怀投笔，慕宗悫之长风。舍簪笏于百龄，奉晨昏于万里。非谢家之宝树，接孟氏之芳邻。他日趋庭，叨陪鲤对；今兹捧袂，喜托龙门。杨意不逢，抚凌云而自惜；钟期既遇，奏流水以何惭？
            呜乎！胜地不常，盛筵难再；兰亭已矣，梓泽丘墟。临别赠言，幸承恩于伟饯；登高作赋，是所望于群公。敢竭鄙怀，恭疏短引；一言均赋，四韵俱成。请洒潘江，各倾陆海云尔：
            滕王高阁临江渚，佩玉鸣鸾罢歌舞。
            画栋朝飞南浦云，珠帘暮卷西山雨。
            闲云潭影日悠悠，物换星移几度秋。
            阁中帝子今何在？槛外长江空自流。\r
            \r
            """;

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 600; i++) {
            new Thread(() -> {
                try {
                    httpPostMultipartFormData(new File("/data/abc.png"));
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }).start();
        }
        System.out.println("线程启动成功");
    }

    private static void httpPostMultipartFormData(File file) throws Exception {
        String host = "172.20.103.88";
        String path = "/fuck/file2";
        int port = 8080;
        try (Socket client = newSocket(host, port);
             OutputStream os = client.getOutputStream();
             InputStream is = client.getInputStream()) {

            // 分隔符，分隔符前面必须加上--，否则不会被识别
            String boundary = UUID.randomUUID().toString().replace("-", "");

            byte[] data = writeFile(file, boundary);

            writeLine(os, "POST " + path + " HTTP/1.1");
            writeLine(os, "host:" + host + ":8080");
            writeLine(os, "Connection:keep-alive");
            writeLine(os, "Content-Type:multipart/form-data;boundary=" + boundary);
            writeLine(os, "Content-Length:" + data.length);
            writeLine(os, null);

            System.out.println("开始上传");
            // int c = 0;
            for (int i = 0; i < data.length; i++) {
                if (i != 0 && i % 100 == 0) {
                    Thread.sleep(8000L);
                    // c++;
                    // if (c == 3) {
                    //     client.close();
                    // }
                    System.out.println("睡一会儿..." + i);
                    os.flush();
                }
                os.write(data[i]);
            }
            os.flush();

            printResponse(is);
        }
    }

    private static byte[] writeFile(File file, String boundary) throws IOException {
        String mimeType = Files.probeContentType(file.toPath());

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        writeLine(os, "--" + boundary);
        writeLine(os, "Content-Disposition: form-data; name=\"file\"; filename=\"abc.png\"");
        writeLine(os, "Content-Type: " + mimeType);
        writeLine(os, null);

        try (InputStream is = new FileInputStream(file)) {
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1) {
                os.write(bytes, 0, len);
            }
        }
        writeLine(os, null);
        writeLine(os, "--" + boundary + "--");
        return os.toByteArray();
    }

    // private static class MultipartFile {
    //     private String header;
    //     private String contentType;
    //     private File file;
    //     private String boundary;
    //
    //     public MultipartFile(File file) {
    //         this.file = file;
    //         this.header = buildHeader();
    //     }
    //
    //     private String buildHeader() {
    //         this.header = new StringBuilder()
    //                 .append("--" + boundary).append(SPLIT)
    //                 .append("Content-Disposition: form-data; name=\"file\"; filename=\"" + file.getName() + "\"").append(SPLIT)
    //                 .toString();
    //     }
    // }

    // private static void httpPostChunked(byte[] data, int segment) throws IOException {
    //     try (Socket client = newSocket("misc.test.com", 443);
    //          OutputStream os = client.getOutputStream();
    //          InputStream is = client.getInputStream()) {
    //
    //         writeLine(os, "POST /dump.htm HTTP/1.1");
    //         writeLine(os, "host:misc.test.com");
    //         writeLine(os, "Connection:close");
    //         writeLine(os, "Transfer-Encoding: chunked");
    //         writeLine(os, null);
    //
    //         int len = data.length / segment;
    //         for (int i = 0; i < segment; i++) {
    //             int size = len;
    //             if (i == segment - 1) {
    //                 size = data.length - (i * len);
    //             }
    //             writeLine(os, Integer.toString(size, 16));
    //             os.write(data, len * i, size);
    //             writeLine(os, null);
    //         }
    //         writeLine(os, "0");
    //         writeLine(os, null);
    //         printResponse(is);
    //     }
    // }

    private static void writeLine(OutputStream os, String str) throws IOException {
        byte[] data;
        if (str != null) {
            data = (str + SPLIT).getBytes(StandardCharsets.UTF_8);
        } else {
            data = SPLIT.getBytes(StandardCharsets.UTF_8);
        }
        os.write(data);
    }

    private static void httpPost(byte[] body) throws Exception {
        String host = "nginx-test.test.cn";
        // String path = "/test/file.htm";
        // String path = "/fuck/file2";
        String path = "/api/test/sleep.htm?ms=100";
        int port = 8080;

        try (Socket client = newSocket(host, port);
             OutputStream os = client.getOutputStream();
             InputStream is = client.getInputStream()) {
            writeLine(os, "POST " + path + " HTTP/1.1");
            writeLine(os, "host:" + host);
            writeLine(os, "Connection:close");
            writeLine(os, "Content-Type:text/plain;charset=utf-8");
            writeLine(os, "Content-Length:" + body.length);
            writeLine(os, null);
            os.flush();

            System.out.println("开始上传");
            for (int i = 0; i < body.length; i++) {
                if (i != 0 && i % 100 == 0) {
                    Thread.sleep(300L);
                    System.out.println("睡一会儿..." + i);
                    os.flush();
                }
                os.write(body[i]);
            }
            os.flush();
            // os.write(body);

            printResponse(is);
        }
    }


    private static Socket newSocket(String host, int port) {
        try {
            if (port == 443) {
                return SSLSocketFactory.getDefault().createSocket(host, port);
            } else {
                return new Socket(host, port);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static void printResponse(InputStream is) throws IOException {
        System.out.println("\n-----输出内容-----\n");
        int length;
        byte[] buffer = new byte[1024];
        while ((length = is.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0, length));
        }
    }
}

/**
 * 参见文档: <a href="https://zh.wikipedia.org/wiki/%E6%B1%89%E5%AD%97%E5%86%85%E7%A0%81%E6%89%A9%E5%B1%95%E8%A7%84%E8%8C%83">汉字内码扩展规范</a>
 * <p>
 * GBK/1:GB2312非汉字符号: A1~A9, A1~FE
 * GBK/2:GB2312汉字: B0~F7, A1~FE
 * GBK/3:扩充汉字: 81~A0, 40~FE (7F除外)
 * GBK/4:扩充汉字: AA~FE, 40~A0 (7F除外)
 * GBK/5:扩充非汉字: A8~A9, 40~A0 (7F除外)
 *
 * @author Gao Youbo
 * @since 2022-08-23 16:34
 */
public class GBK {
    private static final Charset CHARSET = Charset.forName("GBK");

    /**
     * 获取所有GBK编码字符
     */
    public static List<String> getGBK() {
        List<String> words = new ArrayList<>();
        byte[] bytes = new byte[2];

        // GBK/1:GB2312非汉字符号
        for (int b1 = 0xA1; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/2:GB2312汉字
        for (int b1 = 0xB0; b1 <= 0xF7; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/3:扩充汉字
        for (int b1 = 0x81; b1 <= 0xA0; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/4:扩充汉字
        for (int b1 = 0xAA; b1 <= 0xFE; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/5:扩充非汉字
        for (int b1 = 0xA8; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        return words;
    }

    public static boolean isGBK(String str) {
        boolean isGBK = false;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            byte[] bytes = String.valueOf(c).getBytes(CHARSET);
            if (bytes.length == 2) { // GBK 编码为两个字节
                int b1 = bytes[0] & 0xff;
                int b2 = bytes[1] & 0xff;
                if (b1 >= 0xA1 && b1 <= 0xA9 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xB0 && b1 <= 0xF7 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0x81 && b1 <= 0xA0 && b2 >= 0x40 & b2 <= 0xFE && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xAA && b1 <= 0xFE && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xA8 && b1 <= 0xA9 && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }
            }
        }
        return isGBK;
    }
}

/**
 * @author Gao Youbo
 * @since 2022-08-19 10:28
 */
public class Base128 {
    private static final char[] DEFAULT_CHAR_TABLE = {
            '0', '1', '2', '3', '4', '5', '6', '7',
            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
            'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
            'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
            'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
            'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
            'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
            'u', 'v', 'w', 'x', 'y', 'z', '-', '_',

            'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ',
            'ι', 'κ', 'λ', 'μ', 'ν', 'ξ', 'ο', 'π',
            'ρ', 'ς', 'σ', 'τ', 'υ', 'φ', 'χ', 'ψ',
            'ω', 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ',
            'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î',
            'ï', 'ð', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö',
            '÷', 'ø', 'ù', 'ú', 'û', 'ü', 'ý', 'þ',
            'ÿ', 'Ā', 'ā', 'Ă', 'ă', 'Ą', 'ą', 'Ć',
    };

    private final char[] charTable;
    private final HashMap<Character, Integer> indexTable;

    public Base128() {
        this(DEFAULT_CHAR_TABLE);
    }

    public Base128(char[] charTable) {
        this.charTable = charTable;
        this.indexTable = new HashMap<>(charTable.length);
        for (int j = 0; j < charTable.length; j++) {
            indexTable.put(charTable[j], j);
        }
    }

    private String encodeToString(byte[] data) {
        if (data == null || data.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        int tail = 0;
        for (int i = 0; i < data.length; i++) {
            int mov = (i % 7 + 1);
            int curr = 0xFF & data[i];
            int code = tail + (curr >> mov);
            sb.append(charTable[code]);
            tail = (0xFF & (curr << (8 - mov))) >> 1;
            if (mov == 7) {
                sb.append(charTable[tail]);
                tail = 0;
            }
        }
        sb.append(charTable[tail]);
        return sb.toString();
    }

    private byte[] decode(String str) {
        if (StringUtils.isBlank(str)) {
            return new byte[]{};
        }
        int length = (int) Math.floor(str.length() * 0.875);
        byte[] result = new byte[length];
        int idx = 0;
        int head = indexTable.get(str.charAt(0)) << 1;
        for (int i = 1; i < str.length(); ) {
            int mod = i % 8;
            int code = indexTable.get(str.charAt(i++));
            result[idx++] = (byte) (0xFF & (head + (code >> (7 - mod))));
            if (mod == 7) {
                head = 0xFF & (indexTable.get(str.charAt(i++)) << 1);
            } else {
                head = 0xFF & (code << (mod + 1));
            }
        }
        return result;
    }
}

public class IpMatcher {
    public static boolean matchIPV4(String ip, String cidr) {
        String[] ips = ip.split("\\.");
        if (ips.length != 4) {
            return false;
        }
        int ipAddr = (Integer.parseInt(ips[0]) << 24)
                | (Integer.parseInt(ips[1]) << 16)
                | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
        int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
        int mask = 0xFFFFFFFF << (32 - type);
        String cidrIp = cidr.replaceAll("/.*", "");
        String[] cidrIps = cidrIp.split("\\.");
        int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
                | (Integer.parseInt(cidrIps[1]) << 16)
                | (Integer.parseInt(cidrIps[2]) << 8)
                | Integer.parseInt(cidrIps[3]);
        return (ipAddr & mask) == (cidrIpAddr & mask);
    }

    public static void main(String[] args) {
        System.out.println(matchIPV4("172.16.0.1", "172.16.0.0/20"));
    }
}

private static final double EARTH_RADIUS = 6372.796924;

public static GpsInfo getRandomLocation(GpsInfo center, double distance) {
    if (distance <= 0) distance = 50;
    double lat, lon, brg;
    distance = distance / 1000;
    GpsInfo location = new GpsInfo();
    double maxdist = distance;
    maxdist = maxdist / EARTH_RADIUS;
    double startlat = rad(center.getLat());
    double startlon = rad(center.getLon());
    double cosdif = Math.cos(maxdist) - 1;
    double sinstartlat = Math.sin(startlat);
    double cosstartlat = Math.cos(startlat);
    double dist;
    double rad360 = 2 * Math.PI;
    dist = Math.acos((new Random().nextDouble() * cosdif + 1));
    brg = rad360 * new Random().nextDouble();
    lat = Math.asin(sinstartlat * Math.cos(dist) + cosstartlat * Math.sin(dist) * Math.cos(brg));
    lon = deg(normalizeLongitude(startlon * 1 + Math.atan2(Math.sin(brg) * Math.sin(dist) * cosstartlat, Math.cos(dist) - sinstartlat * Math.sin(lat))));
    lat = deg(lat);

    location.setLat(padZeroRight(lat));
    location.setLon(padZeroRight(lon));
    return location;
}

static double rad(double d) {
    return d * Math.PI / 180.0;
}

static double deg(double rd) {
    return (rd * 180 / Math.PI);
}

static double normalizeLongitude(double lon) {
    double n = Math.PI;
    if (lon > n) {
        lon = lon - 2 * n;
    } else if (lon < -n) {
        lon = lon + 2 * n;
    }
    return lon;
}

static double padZeroRight(double s) {
    double sigDigits = 8;
    s = Math.round(s * Math.pow(10, sigDigits)) / Math.pow(10, sigDigits);
    return s;
}

/**
 * 从视频中将每一帧的图片提取出来
 *
 * @param video
 * @return
 * @throws FrameGrabber.Exception
 */
public static List<BufferedImage> grab(File video) throws Exception {
    try (FFmpegFrameGrabber grabber = FFmpegFrameGrabber.createDefault(video.getPath())) {
        grabber.start();

        List<BufferedImage> images = Lists.newArrayList();
        Frame frame;
        while ((frame = grabber.grabImage()) != null) {
            images.add(Java2DFrameUtils.toBufferedImage(frame));
        }
        return images;
    }
}

private static class VideoRecorder implements Closeable {
        private FFmpegFrameRecorder recorder;

        public VideoRecorder(String output, int width, int height) throws FrameRecorder.Exception {
            recorder = new FFmpegFrameRecorder(output, width, height);
            recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
            recorder.setFormat("mp4");
            recorder.setFrameRate(FPS);
            recorder.setAudioBitrate(192000);
            recorder.setSampleRate(44100);
            recorder.setAudioChannels(2);
            recorder.start();
        }

        public void addFrame(BufferedImage image) throws FrameRecorder.Exception {
            Frame frame = Java2DFrameUtils.toFrame(image);
            recorder.record(frame, avutil.AV_PIX_FMT_ARGB);
        }

        public void addAudio(File audioFile) throws FrameGrabber.Exception, FrameRecorder.Exception {
            if (audioFile == null || !audioFile.exists()) {
                return;
            }
            try (FFmpegFrameGrabber grabber = FFmpegFrameGrabber.createDefault(audioFile)) {
                grabber.start();
                Frame frame;
                while ((frame = grabber.grabSamples()) != null) {
                    recorder.recordSamples(frame.sampleRate, frame.audioChannels, frame.samples);
                }
            }
        }

        @Override
        public void close() throws IOException {
            recorder.close();
        }
    }

import java.awt.Color;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.MemoryImageSource;
import java.awt.image.PixelGrabber;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Gao Youbo
 * @since 2014-05-29 14:34:13
 */
public class ImageUtils {

    public static class SplitItem {

        private int x;
        private int w;
        private int y;
        private int h;

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getW() {
            return w;
        }

        public void setW(int w) {
            this.w = w;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }

        public int getH() {
            return h;
        }

        public void setH(int h) {
            this.h = h;
        }

    }


    /**
     * 图片纵向切分（切分为列）
     *
     * @param image
     * @param minWidth 每个汉字的最小宽度，如果汉字的最小宽度小于该参数，那么认为系统将一个汉字截断了
     * @return
     */
    public static List<BufferedImage> splitLengthwaysWithMinWidth(BufferedImage image, int minWidth) {
        if (minWidth < 0) {
            minWidth = 0;
        }
        List<BufferedImage> subImgs = new ArrayList<>();
        int width = image.getWidth();
        int height = image.getHeight();
        int startX = 0;
        int endX = 0;
        boolean start = false;
        boolean end = false;
        for (int x = 0; x < width; ++x) {
            boolean blank = isXBlank(image, x);
            if (!start) { //如果是白色
                int space = spaceX(image, x);
                x = x + space;
                startX = x;
                endX = x;
                start = true;
            }
            if (start && !blank) {
                endX = x;
            }
            int wordLength = endX - startX;
            if (start && blank && wordLength > 0) {
                // 汉字长度小于设定长度，那么认为这不是一个完成的汉字，而是将左右结构的汉字切分成了两份
                if (wordLength < minWidth) {
                    int space = spaceX(image, x);
                    x = x + space;
                } else {
                    end = true;
                    endX = x;
                }
            }
            if (start && end && wordLength > 0) {
                BufferedImage subImage = image.getSubimage(startX, 0, (endX - startX), height);
                subImgs.add(subImage);
                start = false;
                end = false;
            }
        }
        return subImgs;
    }

    /**
     * x轴上的所有点是空白的（白色的）
     *
     * @param image
     * @param x
     * @return
     */
    private static boolean isXBlank(BufferedImage image, int x) {
        int height = image.getHeight();
        for (int y = 0; y < height; y++) {
            int rgb = image.getRGB(x, y);
            if (isBlack(rgb)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 图片纵向切分（切分为列）
     *
     * @param image
     * @param minGap 文字之间的最小间隙，如果间隙文字之间的间隙小于或等于该参数，那么认为该间隙为一个汉字上的正常间隙。主要处理左右结构的一些汉字，例如：”北、川、外...“
     * @return
     */
    public static List<BufferedImage> splitLengthways(BufferedImage image, int minGap) {
        if (minGap < 0) {
            minGap = 0;
        }
        List<BufferedImage> subImgs = new ArrayList<>();
        int width = image.getWidth();
        int height = image.getHeight();
        List<Integer> weightlist = new ArrayList<>();
        for (int x = 0; x < width; ++x) {
            int count = 0;
            for (int y = 0; y < height; ++y) {
                if (isBlack(image.getRGB(x, y))) {
                    count++;
                }
            }
            if (minGap > 0) {
                int space = spaceX(image, x);
                if (space <= minGap) {
                    count = count + space;
                }
            }
            weightlist.add(count);
        }
        List<SplitItem> splitItems = new ArrayList<>();
        for (int i = 0; i < weightlist.size(); i++) {
            int length = 0;
            while (i < weightlist.size() && weightlist.get(i) > 0) {
                i++;
                length++;
            }
            if (length > 0) {
                int x = i - length;
                int w = length;
                int y = 0;
                int h = height;
                SplitItem item = new SplitItem();
                item.setX(x);
                item.setW(w);
                item.setY(y);
                item.setH(h);
                splitItems.add(item);
            }
        }
        for (SplitItem splitItem : splitItems) {
            subImgs.add(image.getSubimage(splitItem.getX(), splitItem.getY(), splitItem.getW(), splitItem.getH()));
        }
        return subImgs;
    }

    /**
     * X轴上两个字之间的间距
     *
     * @param image
     * @param currentX 当前索引所在的x坐标
     * @return
     */
    private static int spaceX(BufferedImage image, int currentX) {
        int w = image.getWidth();
        int h = image.getHeight();
        int spaceLength = 0;
        for (int x = currentX; x < w; x++) {
            boolean space = true;
            for (int y = 0; y < h; y++) {
                if (isBlack(image.getRGB(x, y))) { //有黑色的，表明非空白
                    space = false;
                    break;
                }
            }
            if (space) {
                spaceLength++;
            } else {
                return spaceLength;
            }
        }
        return spaceLength;
    }


    /**
     * y轴上两个字之间的间距
     *
     * @param image
     * @param currentY 当前索引所在的y坐标
     * @return
     */
    private static int spaceY(BufferedImage image, int currentY) {
        int w = image.getWidth();
        int h = image.getHeight();
        int spaceLength = 0;
        for (int y = currentY; y < h; y++) {
            boolean space = true;
            for (int x = 0; x < w; x++) {
                if (isBlack(image.getRGB(x, y))) { //有黑色的，表明非空白
                    space = false;
                    break;
                }
            }
            if (space) {
                spaceLength++;
            } else {
                return spaceLength;
            }
        }
        return spaceLength;
    }


    /**
     * 图片横向切分（切分为行）
     *
     * @param image
     * @param minGap 两行之间的最小间隙,如果间隙小于或等于该参数,那么认为没有折行
     * @return
     */
    public static List<BufferedImage> splitCrosswise(BufferedImage image, int minGap) {
        if (minGap < 0) {
            minGap = 0;
        }
        List<BufferedImage> subImgs = new ArrayList<>();
        int w = image.getWidth();
        int h = image.getHeight();
        List<Integer> heightlist = new ArrayList<>();
        for (int y = 0; y < h; y++) {
            int count = 0;
            for (int x = 0; x < w; x++) {
                if (ImageUtils.isBlack(image.getRGB(x, y))) {
                    count++;
                }
            }
            if (minGap > 0) {
                int space = spaceY(image, y);
                if (space <= minGap) {
                    count = count + space;
                }
            }
            heightlist.add(count);
        }
        for (int i = 0; i < heightlist.size(); i++) {
            int length = 0;
            while (i < heightlist.size() && heightlist.get(i) > 0) {
                i++;
                length++;
            }
            if (length > 0) {
                int y = i - length;
                int x = 0;
                int height = length;
                int width = w;
                BufferedImage bufferedImage = image.getSubimage(x, y, width, height);
                subImgs.add(bufferedImage);
            }
        }
        return subImgs;
    }

    /**
     * 图片横向切分（切分为行）
     *
     * @param image
     * @return
     */
    public static List<BufferedImage> splitCrosswise(BufferedImage image) {
        List<BufferedImage> subImgs = new ArrayList<>();
        int w = image.getWidth();
        int h = image.getHeight();
        List<Integer> heightlist = new ArrayList<>();
        for (int y = 0; y < h; y++) {
            int count = 0;
            for (int x = 0; x < w; x++) {
                if (ImageUtils.isBlack(image.getRGB(x, y))) {
                    count++;
                }
            }
            heightlist.add(count);
        }
        for (int i = 0; i < heightlist.size(); i++) {
            int length = 0;
            while (i < heightlist.size() && heightlist.get(i) > 0) {
                i++;
                length++;
            }
            if (length > 0) {
                int y = i - length;
                int x = 0;
                int height = length;
                int width = w;
                BufferedImage bufferedImage = image.getSubimage(x, y, width, height);
                subImgs.add(bufferedImage);
            }
        }
        return subImgs;
    }

    /**
     * 删除杂色(图片二值化)
     * <p>
     * 默认图片中字体颜色为黑色，如果非黑色像素全部替换为白色
     *
     * @param image
     * @return
     * @throws java.lang.InterruptedException
     */
    public static final BufferedImage removeMotley(BufferedImage image) throws InterruptedException {
        int width = image.getWidth();
        int height = image.getHeight();
        int[] pixels = new int[width * height];
        int grey = 100;
        PixelGrabber pixelGrabber = new PixelGrabber(image.getSource(), 0, 0, width, height, pixels, 0, width);
        pixelGrabber.grabPixels();
        ColorModel cm = ColorModel.getRGBdefault();
        for (int i = 0; i < width * height; i++) {
            int red, green, blue;
            int alpha = cm.getAlpha(pixels[i]);
            if (cm.getRed(pixels[i]) > grey) {
                red = 255;
            } else {
                red = 0;
            }
            if (cm.getGreen(pixels[i]) > grey) {
                green = 255;
            } else {
                green = 0;
            }
            if (cm.getBlue(pixels[i]) > grey) {
                blue = 255;
            } else {
                blue = 0;
            }
            pixels[i] = alpha << 24 | red << 16 | green << 8 | blue; //通过移位重新构成某一点像素的RGB值
        }
        //将数组中的象素产生一个图像
        Image tempImg = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(width, height, pixels, 0, width));
        image = new BufferedImage(tempImg.getWidth(null), tempImg.getHeight(null), BufferedImage.TYPE_INT_BGR);
        image.createGraphics().drawImage(tempImg, 0, 0, null);
        return image;
    }

    /**
     * 清除空白部分
     *
     * @param image
     * @return
     */
    public static BufferedImage removeSpace(BufferedImage image) {
        BufferedImage result = removeTBWhite(image);
        return removeLRWhite(result);
    }

    /**
     * 移除上下白色部分（top bottom）
     *
     * @param image
     * @return
     */
    public static BufferedImage removeTBWhite(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int start = 0;
        int end = 0;
        Label1:
        for (int y = 0; y < height; ++y) {
            int count = 0;
            for (int x = 0; x < width; ++x) {
                if (isBlack(image.getRGB(x, y))) {
                    count++;
                }
                if (count >= 1) {
                    start = y;
                    break Label1;
                }
            }
        }
        Label2:
        for (int y = height - 1; y >= 0; --y) {
            int count = 0;
            for (int x = 0; x < width; ++x) {
                if (isBlack(image.getRGB(x, y))) {
                    count++;
                }
                if (count >= 1) {
                    end = y;
                    break Label2;
                }
            }
        }
        return image.getSubimage(0, start, width, end - start + 1);
    }

    /**
     * 移除左右白色部分（left right）
     *
     * @param image
     * @return
     */
    public static BufferedImage removeLRWhite(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int start = 0;
        int end = 0;
        Label1:
        for (int x = 0; x < width; ++x) {
            int count = 0;
            for (int y = 0; y < height; ++y) {
                if (isBlack(image.getRGB(x, y))) {
                    count++;
                }
                if (count >= 1) {
                    start = x;
                    break Label1;
                }
            }
        }
        Label2:
        for (int x = width - 1; x >= 0; --x) {
            int count = 0;
            for (int y = height - 1; y >= 0; --y) {
                if (isBlack(image.getRGB(x, y))) {
                    count++;
                }
                if (count >= 1) {
                    end = x;
                    break Label2;
                }
            }
        }
        return image.getSubimage(start, 0, end - start + 1, height);
    }

    /**
     * 移除黑色部分
     *
     * @param img
     * @return
     */
    public static BufferedImage removeBlack(BufferedImage img) {
        int width = img.getWidth();
        int height = img.getHeight();
        int start = 0;
        int end = 0;
        Label1:
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; ++x) {
                if (isBlack(img.getRGB(x, y))) {
                    start = y;
                    break Label1;
                }
            }
        }
        Label2:
        for (int y = height - 1; y >= 0; --y) {
            for (int x = 0; x < width; ++x) {
                if (isBlack(img.getRGB(x, y))) {
                    end = y;
                    break Label2;
                }
            }
        }
        return img.getSubimage(0, start, width, end - start + 1);
    }

    /**
     * 是否是黑色
     *
     * @param colorInt
     * @return
     */
    public static boolean isBlack(int colorInt) {
        Color color = new Color(colorInt);
        return color.getRed() + color.getGreen() + color.getBlue() <= 100;
    }

    /**
     * 是否是白色
     *
     * @param colorInt
     * @return
     */
    public static boolean isWhite(int colorInt) {
        Color color = new Color(colorInt);
        return color.getRed() + color.getGreen() + color.getBlue() > 100;
    }
}