package com.colin.tool.img;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;

/**
 * @author colin.cheng
 * @date 2022-01-14 19:39
 * @since 1.0.0
 */
public class ImageBuilder {

    private BufferedImage bufferedImage;
    private Graphics graphics;

    private Font defaultFont = new Font(null, Font.BOLD, 28);
    private Color defaultColor = new Color(120, 120, 120);

    public ImageBuilder(int width, int height) {
        this(width, height, BufferedImage.TYPE_INT_BGR);
    }

    public ImageBuilder(File img) throws FileNotFoundException, IOException {
        try (final FileInputStream inputStream = new FileInputStream(img)) {
            init(ImageIO.read(inputStream));
        }
    }

    public ImageBuilder(BufferedImage bufferedImage) {
        init(bufferedImage);
    }

    public ImageBuilder(int width, int height, int imageType) {
        init(new BufferedImage(width, height, imageType));
    }

    private void init(BufferedImage bufferedImage) {
        this.bufferedImage = bufferedImage;
        graphics = bufferedImage.getGraphics();
        graphics.setColor(this.defaultColor);
        graphics.setFont(this.defaultFont);
    }

    public void drawText(String content, int x, int y) {
        graphics.drawString(content, x, y);
    }

    public void fillRect(int x, int y, int width, int height) {
        graphics.fillRect(x, y, width, height);
    }

    public void drawImg(BufferedImage img, int x, int y, int w, int h) {
        graphics.drawImage(img, x, y, w, h, null);
    }

    public ImageBuilder cut(int x, int y, int w, int h) {
        final BufferedImage subImage = bufferedImage.getSubimage(x, y, w, h);
        return new ImageBuilder(subImage);
    }

    public BufferedImage toImage() {
        return this.bufferedImage;
    }

    public boolean writeToFile(File file, String imgType) throws IOException {
        return ImageIO.write(this.bufferedImage, imgType, file);
    }


    // setter

    public void setFont(Font font) {
        graphics.setFont(font);
    }

    public void setColor(Color color) {
        graphics.setColor(color);
    }

    public int getWidth() {
        return bufferedImage.getWidth();
    }

    public int getHeight() {
        return bufferedImage.getHeight();
    }

    // static
}

package com.colin.tool.img;

import java.awt.*;
import java.awt.image.BufferedImage;

/**
 * @author colin.cheng
 * @date 2022-01-17
 * @since 1.0.0
 */
public class ImageUtil {

    public static ImageBuilder getComicStrip(BufferedImage[] imgArray, int outHeight) {
        int showW = outHeight, showH = outHeight;
        final ImageBuilder imageBuilder = new ImageBuilder(showW * imgArray.length, showH, Color.BLACK);
        for (int i = 0; i < imgArray.length; i++) {
            BufferedImage image = imgArray[i];
            final int height = image.getHeight();
            final int width = image.getWidth();
            if (height == width) {
                imageBuilder.drawImg(image, i * showW, 0, showW, showH);
            } else {
                if(height > width) {
                    double n = (double) height / showH;
                    double w = width / n;
                    imageBuilder.drawImg(image, (int)(showW * i + (showH - w) / 2), 0, (int)w, showH);
                } else {
                    double n = (double) width / showW;
                    double h = height / n;
                    imageBuilder.drawImg(image, showW * i, (int)((showW - h) / 2), showW, (int)h);
                }
            }
        }
        return imageBuilder;
    }

    public static ImageBuilder addComicStripIndex(BufferedImage comicStrip, float transparency, int strokeWidth) {
        final int width = comicStrip.getWidth(), height = comicStrip.getHeight(), offset = height;
        int length = width / height;
        final ImageBuilder imageBuilder = new ImageBuilder(width + offset, height);
        BufferedImage banner = ImageBuilder.cut(comicStrip, 0, 0, height, height);
        imageBuilder.drawImg(banner, 0, 0, height, height);
        imageBuilder.drawImg(comicStrip, offset, 0, width, height);
        for (int i = 0; i < length; i++) {
            double w = height - strokeWidth, base = width / w, h = height / base;
            final int x = height * i + offset + strokeWidth / 2, y = (int)(height - h);
            imageBuilder.drawTranslucentImage(comicStrip, x, y, (int)w, (int)h, transparency);
            // 画框
            if(strokeWidth > 0) {
                imageBuilder.setColor(Color.BLACK);
                imageBuilder.drawRect(x + (i * (int)h), y, (int)h, (int)h, strokeWidth);
            }
            // 当前所在的关键帧变清晰
            if(transparency < 1) {
                BufferedImage frame = ImageBuilder.cut(comicStrip, height * i, 0, height, height);
                imageBuilder.drawImg(frame, x + (i * (int)h), y, (int)h, (int)h);
            }
        }
        return imageBuilder;
    }
}

package com.colin.tool.img;

import org.bytedeco.javacpp.BytePointer;
import org.bytedeco.leptonica.PIX;
import org.bytedeco.leptonica.global.lept;
import org.bytedeco.tesseract.TessBaseAPI;

/**
 * @author colin.cheng
 * @date 2022-01-17
 * @since 1.0.0
 */
public class ImageUtil {

    public static String ocr(String imagePath, OcrLanguage language) {
        TessBaseAPI api=new TessBaseAPI();
        if (api.Init(language.getPath(), language.getLangName()) != 0) {
            api.End();
            return "";
        }
        PIX image = lept.pixRead(imagePath);
        if (image == null) {
            return "";
        }
        api.SetImage(image);
        BytePointer outText=api.GetUTF8Text();
        String result=outText.getString();
        api.End();
        outText.deallocate();
        lept.pixDestroy(image);
        return result;
    }

    public static void main(String[] args) {
        String text = ocr("F:\\test\\img\\0.jpg", OcrLanguage.ZH_CN);
        System.out.println(text);
    }

    public enum OcrLanguage {
        /** 简体中文 */
        ZH_CN("chi_sim", "F:\\test\\img\\traineddata"),
        /** 英文 */
        EN("eng", "F:\\test\\img\\traineddata");

        /** 文件名 */
        private String langName;
        /** 所在文件夹 */
        private String path;

        OcrLanguage(String langName, String path) {
            this.langName = langName;
            this.path = path;
        }

        public String getLangName() {
            return langName;
        }

        public String getPath() {
            return path;
        }
    }
}

redisTemplate.getConnectionFactory().getConnection().info()

public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
        Assert.isTrue(this.initialized, "template not initialized; call afterPropertiesSet() before using it");
        Assert.notNull(action, "Callback object must not be null");
        RedisConnectionFactory factory = this.getConnectionFactory();
        RedisConnection conn = null;

        Object var11;
        try {
            if (this.enableTransactionSupport) {
                conn = RedisConnectionUtils.bindConnection(factory, this.enableTransactionSupport);
            } else {
                conn = RedisConnectionUtils.getConnection(factory);
            }

            boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);
            RedisConnection connToUse = this.preProcessConnection(conn, existingConnection);
            boolean pipelineStatus = connToUse.isPipelined();
            if (pipeline && !pipelineStatus) {
                connToUse.openPipeline();
            }

            RedisConnection connToExpose = exposeConnection ? connToUse : this.createRedisConnectionProxy(connToUse);
            T result = action.doInRedis(connToExpose);
            if (pipeline && !pipelineStatus) {
                connToUse.closePipeline();
            }

            var11 = this.postProcessResult(result, connToUse, existingConnection);
        } finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }

        return var11;
    }

RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection conn = null;
        try {
            conn = RedisConnectionUtils.getConnection(factory);
            redisInfo = conn.info();
        } finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }

//B应用为服务端：将udp监听放到一个线程中，当有客户端请求时就会进行响应
/**
 * udp连接，用于动态ip, pos向255.255.255.255：5060发送请求即可
 * **/
public class UdpServer extends Thread implements Runnable {
    private final int MAX_LENGTH = 1024;
    private final int PORT = 5060;
    private DatagramSocket datagramSocket;
    
    public void run() {
        try {
            init();
            while(true){
                try {
                    byte[] buffer = new byte[MAX_LENGTH];
                    DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                    receive(packet);
                    String receStr = new String(packet.getData(), 0 , packet.getLength());
                    System.out.println("接收数据包" + receStr);
                    byte[] bt = new byte[packet.getLength()];
                    
                    System.arraycopy(packet.getData(), 0, bt, 0, packet.getLength());
                    System.out.println(packet.getAddress().getHostAddress() + "：" + packet.getPort() + "：" + Arrays.toString(bt));
                    packet.setData(bt);
                    response(packet);
                    
                } catch (Exception e) {
                    e.printStackTrace();
                    LoggerUtil.error("udp线程出现异常：" + e.toString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void receive(DatagramPacket packet) throws Exception {
        datagramSocket.receive(packet);
    }

    public void response(DatagramPacket packet) throws Exception {
        datagramSocket.send(packet);
    }
    
    /**
     * 初始化连接
     */
    public void init(){
        try {
            datagramSocket = new DatagramSocket(PORT);
            System.out.println("udp服务端已经启动！");
        } catch (Exception e) {
            datagramSocket = null;
            System.out.println("udp服务端启动失败！");
            e.printStackTrace();
        }
    }
}

/***
 * UDP Client端
 ***/
public class UdpClient {
   
    private String sendStr = "hello";
    private String netAddress = "255.255.255.255";
    private final int PORT = 5060;
   
    private DatagramSocket datagramSocket;
    private DatagramPacket datagramPacket;
   
    public UdpClient(){
        try { 
            datagramSocket = new DatagramSocket();
            byte[] buf = sendStr.getBytes();
            InetAddress address = InetAddress.getByName(netAddress);
            datagramPacket = new DatagramPacket(buf, buf.length, address, PORT);
            datagramSocket.send(datagramPacket);
           
            byte[] receBuf = new byte[1024];
            DatagramPacket recePacket = new DatagramPacket(receBuf, receBuf.length);
            datagramSocket.receive(recePacket);
           
            String receStr = new String(recePacket.getData(), 0 , recePacket.getLength());
            
　　　　　　　//获取服务端ip
            String serverIp = recePacket.getAdress();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭socket
            if(datagramSocket != null){
                datagramSocket.close();
            }
        }
    }
    
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    UdpClient udpClient = new UdpClient();
                }
            }).start();
        }
    }
}