Java-生成动态图片验证码

傷城~ 2023-10-07 16:33 173阅读 0赞

先看效果：
2022010707060742415.gif
获取验证码接口：

  1. @Override
  2.     public Map getPictureCode() {
  4.         GifCaptcha gifCaptcha = new GifCaptcha(130, 48, 5);
  5.         Map<String, Object> map = new HashMap<>();
  6.         String key = UUID.randomUUID().toString();
  7.         String verCode = gifCaptcha.text().toLowerCase();
  8.         map.put("key", key);
  9.         map.put("image", gifCaptcha.toBase64());
  10.         System.out.println(verCode);
  12.         redisTemplate.opsForValue().set(key, verCode, 5, TimeUnit.MINUTES);
  14.         return map;
  15.     }

接口返回的参数是这样的（data:image/gif;base64,格式的）：

  1. {
  2.     "code": "200",
  3.     "data": {
  4.         "image": "https://img-blog.csdnimg.cn/2022010707060742415.gif",
  5.         "key": "bd13a0fb-1b8a-42bc-9af1-662dfda4e309"
  6.     },
  7.     "message": "请求成功!"
  8. }

然后我们可以通过下面这个文本打开，先创建一个txt文本，将接口返回的参数放入下面的![Image 1][]标签中，将后缀改为html,保存后双击打开就可以看到效果了。

  1. <!DOCTYPE html>
  2. <html>
  3.     <head>
  4.         <title>标题</title>
  5.     </head>
  6.     <body>
  8.         <p>Hello World！</p>
  10.         <img src="https://img-blog.csdnimg.cn/2022010707060742415.gif"/>
  13.     </body>
  14. </html>

打开效果：
在这里插入图片描述

验证码生成工具类：

  1. import java.awt.*;
  2. import java.awt.geom.CubicCurve2D;
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. import java.io.OutputStream;
  7. public class GifCaptcha extends Captcha {
  10.     public GifCaptcha() {
  12.     }
  14.     public GifCaptcha(int width, int height) {
  16.         setWidth(width);
  17.         setHeight(height);
  18.     }
  20.     public GifCaptcha(int width, int height, int len) {
  22.         this(width, height);
  23.         setLen(len);
  24.     }
  26.     public GifCaptcha(int width, int height, int len, Font font) {
  28.         this(width, height, len);
  29.         setFont(font);
  30.     }
  32.     @Override
  33.     public boolean out(OutputStream os) {
  35.         try {
  37.             char[] strs = textChar();  // 获取验证码数组
  38.             // 随机生成每个文字的颜色
  39.             Color fontColor[] = new Color[len];
  40.             for (int i = 0; i < len; i++) {
  42.                 fontColor[i] = color();
  43.             }
  44.             // 随机生成贝塞尔曲线参数
  45.             int x1 = 5, y1 = num(5, height / 2);
  46.             int x2 = width - 5, y2 = num(height / 2, height - 5);
  47.             int ctrlx = num(width / 4, width / 4 * 3), ctrly = num(5, height - 5);
  48.             if (num(2) == 0) {
  50.                 int ty = y1;
  51.                 y1 = y2;
  52.                 y2 = ty;
  53.             }
  54.             int ctrlx1 = num(width / 4, width / 4 * 3), ctrly1 = num(5, height - 5);
  55.             int[][] besselXY = new int[][]{
  56.     {
  57.     x1, y1}, {
  58.     ctrlx, ctrly}, {
  59.     ctrlx1, ctrly1}, {
  60.     x2, y2}};
  61.             // 开始画gif每一帧
  62.             GifEncoder gifEncoder = new GifEncoder();
  63.             gifEncoder.setQuality(180);
  64.             gifEncoder.setDelay(100);
  65.             gifEncoder.setRepeat(0);
  66.             gifEncoder.start(os);
  67.             for (int i = 0; i < len; i++) {
  69.                 BufferedImage frame = graphicsImage(fontColor, strs, i, besselXY);
  70.                 gifEncoder.addFrame(frame);
  71.                 frame.flush();
  72.             }
  73.             gifEncoder.finish();
  74.             return true;
  75.         } catch (Exception e) {
  77.             e.printStackTrace();
  78.         } finally {
  80.             try {
  82.                 os.close();
  83.             } catch (IOException e) {
  85.                 e.printStackTrace();
  86.             }
  87.         }
  88.         return false;
  89.     }
  91.     @Override
  92.     public String toBase64() {
  94.         return toBase64("data:image/gif;base64,");
  95.     }
  97.     /**
  98.      * 画随机码图
  99.      *
  100.      * @param fontColor 随机字体颜色
  101.      * @param strs      字符数组
  102.      * @param flag      透明度
  103.      * @param besselXY  干扰线参数
  104.      * @return BufferedImage
  105.      */
  106.     private BufferedImage graphicsImage(Color[] fontColor, char[] strs, int flag, int[][] besselXY) {
  108.         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
  109.         Graphics2D g2d = (Graphics2D) image.getGraphics();
  110.         // 填充背景颜色
  111.         g2d.setColor(Color.WHITE);
  112.         g2d.fillRect(0, 0, width, height);
  113.         // 抗锯齿
  114.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  115.         // 画干扰圆圈
  116.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.1f * num(10)));  // 设置透明度
  117.         drawOval(2, g2d);
  118.         // 画干扰线
  119.         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.7f));  // 设置透明度
  120.         g2d.setStroke(new BasicStroke(1.2f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
  121.         g2d.setColor(fontColor[0]);
  122.         CubicCurve2D shape = new CubicCurve2D.Double(besselXY[0][0], besselXY[0][1], besselXY[1][0], besselXY[1][1], besselXY[2][0], besselXY[2][1], besselXY[3][0], besselXY[3][1]);
  123.         g2d.draw(shape);
  124.         // 画验证码
  125.         g2d.setFont(getFont());
  126.         FontMetrics fontMetrics = g2d.getFontMetrics();
  127.         int fW = width / strs.length;  // 每一个字符所占的宽度
  128.         int fSp = (fW - (int) fontMetrics.getStringBounds("W", g2d).getWidth()) / 2;  // 字符的左右边距
  129.         for (int i = 0; i < strs.length; i++) {
  131.             // 设置透明度
  132.             AlphaComposite ac3 = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getAlpha(flag, i));
  133.             g2d.setComposite(ac3);
  134.             g2d.setColor(fontColor[i]);
  135.             int fY = height - ((height - (int) fontMetrics.getStringBounds(String.valueOf(strs[i]), g2d).getHeight()) >> 1);  // 文字的纵坐标
  136.             g2d.drawString(String.valueOf(strs[i]), i * fW + fSp + 3, fY - 3);
  137.         }
  138.         g2d.dispose();
  139.         return image;
  140.     }
  142.     /**
  143.      * 获取透明度,从0到1,自动计算步长
  144.      *
  145.      * @param i
  146.      * @param j
  147.      * @return 透明度
  148.      */
  149.     private float getAlpha(int i, int j) {
  151.         int num = i + j;
  152.         float r = (float) 1 / (len - 1);
  153.         float s = len * r;
  154.         return num >= len ? (num * r - s) : num * r;
  155.     }
  157. }

其它辅助工具：

  1. import java.awt.*;
  2. import java.awt.geom.CubicCurve2D;
  3. import java.awt.geom.QuadCurve2D;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. import java.util.Base64;
  9. public abstract class Captcha extends Randoms {
  11.     // 常用颜色
  12.     public static final int[][] COLOR = {
  13.     {
  14.     0, 135, 255}, {
  15.     51, 153, 51}, {
  16.     255, 102, 102}, {
  17.     255, 153, 0}, {
  18.     153, 102, 0}, {
  19.     153, 102, 153}, {
  20.     51, 153, 153}, {
  21.     102, 102, 255}, {
  22.     0, 102, 204}, {
  23.     204, 51, 51}, {
  24.     0, 153, 204}, {
  25.     0, 51, 102}};
  26.     // 验证码文本类型
  27.     public static final int TYPE_DEFAULT = 1;  // 字母数字混合
  28.     public static final int TYPE_ONLY_NUMBER = 2;  // 纯数字
  29.     public static final int TYPE_ONLY_CHAR = 3;  // 纯字母
  30.     public static final int TYPE_ONLY_UPPER = 4;  // 纯大写字母
  31.     public static final int TYPE_ONLY_LOWER = 5;  // 纯小写字母
  32.     public static final int TYPE_NUM_AND_UPPER = 6;  // 数字大写字母
  33.     // 内置字体
  34.     public static final int FONT_1 = 0;
  35.     public static final int FONT_2 = 1;
  36.     public static final int FONT_3 = 2;
  37.     public static final int FONT_4 = 3;
  38.     public static final int FONT_5 = 4;
  39.     public static final int FONT_6 = 5;
  40.     public static final int FONT_7 = 6;
  41.     public static final int FONT_8 = 7;
  42.     public static final int FONT_9 = 8;
  43.     public static final int FONT_10 = 9;
  44.     private static final String[] FONT_NAMES = new String[]{
  45.     "actionj.ttf", "epilog.ttf", "fresnel.ttf", "headache.ttf", "lexo.ttf", "prefix.ttf", "progbot.ttf", "ransom.ttf", "robot.ttf", "scandal.ttf"};
  46.     private Font font = null; // 验证码的字体
  47.     protected int len = 5; // 验证码随机字符长度
  48.     protected int width = 130; // 验证码显示宽度
  49.     protected int height = 48; // 验证码显示高度
  50.     protected int charType = TYPE_DEFAULT;  // 验证码类型
  51.     protected String chars = null; // 当前验证码
  53.     /**
  54.      * 生成随机验证码
  55.      *
  56.      * @return 验证码字符数组
  57.      */
  58.     protected char[] alphas() {
  60.         char[] cs = new char[len];
  61.         for (int i = 0; i < len; i++) {
  63.             switch (charType) {
  65.                 case 2:
  66.                     cs[i] = alpha(numMaxIndex);
  67.                     break;
  68.                 case 3:
  69.                     cs[i] = alpha(charMinIndex, charMaxIndex);
  70.                     break;
  71.                 case 4:
  72.                     cs[i] = alpha(upperMinIndex, upperMaxIndex);
  73.                     break;
  74.                 case 5:
  75.                     cs[i] = alpha(lowerMinIndex, lowerMaxIndex);
  76.                     break;
  77.                 case 6:
  78.                     cs[i] = alpha(upperMaxIndex);
  79.                     break;
  80.                 default:
  81.                     cs[i] = alpha();
  82.             }
  83.         }
  84.         chars = new String(cs);
  85.         return cs;
  86.     }
  88.     /**
  89.      * 给定范围获得随机颜色
  90.      *
  91.      * @param fc 0-255
  92.      * @param bc 0-255
  93.      * @return 随机颜色
  94.      */
  95.     protected Color color(int fc, int bc) {
  97.         if (fc > 255)
  98.             fc = 255;
  99.         if (bc > 255)
  100.             bc = 255;
  101.         int r = fc + num(bc - fc);
  102.         int g = fc + num(bc - fc);
  103.         int b = fc + num(bc - fc);
  104.         return new Color(r, g, b);
  105.     }
  107.     /**
  108.      * 获取随机常用颜色
  109.      *
  110.      * @return 随机颜色
  111.      */
  112.     protected Color color() {
  114.         int[] color = COLOR[num(COLOR.length)];
  115.         return new Color(color[0], color[1], color[2]);
  116.     }
  118.     /**
  119.      * 验证码输出,抽象方法，由子类实现
  120.      *
  121.      * @param os 输出流
  122.      * @return 是否成功
  123.      */
  124.     public abstract boolean out(OutputStream os);
  126.     /**
  127.      * 输出base64编码
  128.      *
  129.      * @return base64编码字符串
  130.      */
  131.     public abstract String toBase64();
  133.     /**
  134.      * 输出base64编码
  135.      *
  136.      * @param type 编码头
  137.      * @return base64编码字符串
  138.      */
  139.     public String toBase64(String type) {
  141.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  142.         out(outputStream);
  143.         return type + Base64.getEncoder().encodeToString(outputStream.toByteArray());
  144.     }
  146.     /**
  147.      * 获取当前的验证码
  148.      *
  149.      * @return 字符串
  150.      */
  151.     public String text() {
  153.         checkAlpha();
  154.         return chars;
  155.     }
  157.     /**
  158.      * 获取当前验证码的字符数组
  159.      *
  160.      * @return 字符数组
  161.      */
  162.     public char[] textChar() {
  164.         checkAlpha();
  165.         return chars.toCharArray();
  166.     }
  168.     /**
  169.      * 检查验证码是否生成，没有则立即生成
  170.      */
  171.     public void checkAlpha() {
  173.         if (chars == null) {
  175.             alphas(); // 生成验证码
  176.         }
  177.     }
  179.     /**
  180.      * 随机画干扰线
  181.      *
  182.      * @param num 数量
  183.      * @param g   Graphics2D
  184.      */
  185.     public void drawLine(int num, Graphics2D g) {
  187.         drawLine(num, null, g);
  188.     }
  190.     /**
  191.      * 随机画干扰线
  192.      *
  193.      * @param num   数量
  194.      * @param color 颜色
  195.      * @param g     Graphics2D
  196.      */
  197.     public void drawLine(int num, Color color, Graphics2D g) {
  199.         for (int i = 0; i < num; i++) {
  201.             g.setColor(color == null ? color() : color);
  202.             int x1 = num(-10, width - 10);
  203.             int y1 = num(5, height - 5);
  204.             int x2 = num(10, width + 10);
  205.             int y2 = num(2, height - 2);
  206.             g.drawLine(x1, y1, x2, y2);
  207.         }
  208.     }
  210.     /**
  211.      * 随机画干扰圆
  212.      *
  213.      * @param num 数量
  214.      * @param g   Graphics2D
  215.      */
  216.     public void drawOval(int num, Graphics2D g) {
  218.         drawOval(num, null, g);
  219.     }
  221.     /**
  222.      * 随机画干扰圆
  223.      *
  224.      * @param num   数量
  225.      * @param color 颜色
  226.      * @param g     Graphics2D
  227.      */
  228.     public void drawOval(int num, Color color, Graphics2D g) {
  230.         for (int i = 0; i < num; i++) {
  232.             g.setColor(color == null ? color() : color);
  233.             int w = 5 + num(10);
  234.             g.drawOval(num(width - 25), num(height - 15), w, w);
  235.         }
  236.     }
  238.     /**
  239.      * 随机画贝塞尔曲线
  240.      *
  241.      * @param num 数量
  242.      * @param g   Graphics2D
  243.      */
  244.     public void drawBesselLine(int num, Graphics2D g) {
  246.         drawBesselLine(num, null, g);
  247.     }
  249.     /**
  250.      * 随机画贝塞尔曲线
  251.      *
  252.      * @param num   数量
  253.      * @param color 颜色
  254.      * @param g     Graphics2D
  255.      */
  256.     public void drawBesselLine(int num, Color color, Graphics2D g) {
  258.         for (int i = 0; i < num; i++) {
  260.             g.setColor(color == null ? color() : color);
  261.             int x1 = 5, y1 = num(5, height / 2);
  262.             int x2 = width - 5, y2 = num(height / 2, height - 5);
  263.             int ctrlx = num(width / 4, width / 4 * 3), ctrly = num(5, height - 5);
  264.             if (num(2) == 0) {
  266.                 int ty = y1;
  267.                 y1 = y2;
  268.                 y2 = ty;
  269.             }
  270.             if (num(2) == 0) {
  271.       // 二阶贝塞尔曲线
  272.                 QuadCurve2D shape = new QuadCurve2D.Double();
  273.                 shape.setCurve(x1, y1, ctrlx, ctrly, x2, y2);
  274.                 g.draw(shape);
  275.             } else {
  276.       // 三阶贝塞尔曲线
  277.                 int ctrlx1 = num(width / 4, width / 4 * 3), ctrly1 = num(5, height - 5);
  278.                 CubicCurve2D shape = new CubicCurve2D.Double(x1, y1, ctrlx, ctrly, ctrlx1, ctrly1, x2, y2);
  279.                 g.draw(shape);
  280.             }
  281.         }
  282.     }
  284.     public Font getFont() {
  286.         if (font == null) {
  288.             try {
  290.                 setFont(FONT_1);
  291.             } catch (Exception e) {
  293.                 setFont(new Font("Arial", Font.BOLD, 32));
  294.             }
  295.         }
  296.         return font;
  297.     }
  299.     public void setFont(Font font) {
  301.         this.font = font;
  302.     }
  304.     public void setFont(int font) throws IOException, FontFormatException {
  306.         setFont(font, 32f);
  307.     }
  309.     public void setFont(int font, float size) throws IOException, FontFormatException {
  311.         setFont(font, Font.BOLD, size);
  312.     }
  314.     public void setFont(int font, int style, float size) throws IOException, FontFormatException {
  316.         this.font = Font.createFont(Font.TRUETYPE_FONT, getClass().getResourceAsStream("/" + FONT_NAMES[font])).deriveFont(style, size);
  317.     }
  319.     public int getLen() {
  321.         return len;
  322.     }
  324.     public void setLen(int len) {
  326.         this.len = len;
  327.     }
  329.     public int getWidth() {
  331.         return width;
  332.     }
  334.     public void setWidth(int width) {
  336.         this.width = width;
  337.     }
  339.     public int getHeight() {
  341.         return height;
  342.     }
  344.     public void setHeight(int height) {
  346.         this.height = height;
  347.     }
  349.     public int getCharType() {
  351.         return charType;
  352.     }
  354.     public void setCharType(int charType) {
  356.         this.charType = charType;
  357.     }
  358. }
  360. import java.security.SecureRandom;
  362. public class Randoms {
  364.     protected static final SecureRandom RANDOM = new SecureRandom();
  365.     // 定义验证码字符.去除了0、O、I、L等容易混淆的字母
  366.     public static final char ALPHA[] = {
  367.     '2', '3', '4', '5', '6', '7', '8', '9',
  368.             'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  369.             'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
  370.     protected static final int numMaxIndex = 8;  // 数字的最大索引，不包括最大值
  371.     protected static final int charMinIndex = numMaxIndex;  // 字符的最小索引，包括最小值
  372.     protected static final int charMaxIndex = ALPHA.length;  // 字符的最大索引，不包括最大值
  373.     protected static final int upperMinIndex = charMinIndex;  // 大写字符最小索引
  374.     protected static final int upperMaxIndex = upperMinIndex + 23;  // 大写字符最大索引
  375.     protected static final int lowerMinIndex = upperMaxIndex;  // 小写字母最小索引
  376.     protected static final int lowerMaxIndex = charMaxIndex;  // 小写字母最大索引
  378.     /**
  379.      * 产生两个数之间的随机数
  380.      *
  381.      * @param min 最小值
  382.      * @param max 最大值
  383.      * @return 随机数
  384.      */
  385.     public static int num(int min, int max) {
  387.         return min + RANDOM.nextInt(max - min);
  388.     }
  390.     /**
  391.      * 产生0-num的随机数,不包括num
  392.      *
  393.      * @param num 最大值
  394.      * @return 随机数
  395.      */
  396.     public static int num(int num) {
  398.         return RANDOM.nextInt(num);
  399.     }
  401.     /**
  402.      * 返回ALPHA中的随机字符
  403.      *
  404.      * @return 随机字符
  405.      */
  406.     public static char alpha() {
  408.         return ALPHA[num(ALPHA.length)];
  409.     }
  411.     /**
  412.      * 返回ALPHA中第0位到第num位的随机字符
  413.      *
  414.      * @param num 到第几位结束
  415.      * @return 随机字符
  416.      */
  417.     public static char alpha(int num) {
  419.         return ALPHA[num(num)];
  420.     }
  422.     /**
  423.      * 返回ALPHA中第min位到第max位的随机字符
  424.      *
  425.      * @param min 从第几位开始
  426.      * @param max 到第几位结束
  427.      * @return 随机字符
  428.      */
  429.     public static char alpha(int min, int max) {
  431.         return ALPHA[num(min, max)];
  432.     }
  433. }
  435. import java.io.IOException;
  436. import java.io.OutputStream;
  438. public class Encoder {
  440.     private static final int EOF = -1;
  441.     // 图片的宽高
  442.     private int imgW, imgH;
  443.     private byte[] pixAry;
  444.     private int initCodeSize;  // 验证码位数
  445.     private int remaining;  // 剩余数量
  446.     private int curPixel;  // 像素
  448.     static final int BITS = 12;
  450.     static final int HSIZE = 5003; // 80% 占用率
  452.     int n_bits; // number of bits/code
  453.     int maxbits = BITS; // user settable max # bits/code
  454.     int maxcode; // maximum code, given n_bits
  455.     int maxmaxcode = 1 << BITS; // should NEVER generate this code
  457.     int[] htab = new int[HSIZE];
  458.     int[] codetab = new int[HSIZE];
  460.     int hsize = HSIZE; // for dynamic table sizing
  462.     int free_ent = 0; // first unused entry
  464.     // block compression parameters -- after all codes are used up,
  465.     // and compression rate changes, start over.
  466.     boolean clear_flg = false;
  468.     // Algorithm:  use open addressing double hashing (no chaining) on the
  469.     // prefix code / next character combination.  We do a variant of Knuth's
  470.     // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  471.     // secondary probe.  Here, the modular division first probe is gives way
  472.     // to a faster exclusive-or manipulation.  Also do block compression with
  473.     // an adaptive reset, whereby the code table is cleared when the compression
  474.     // ratio decreases, but after the table fills.  The variable-length output
  475.     // codes are re-sized at this point, and a special CLEAR code is generated
  476.     // for the decompressor.  Late addition:  construct the table according to
  477.     // file size for noticeable speed improvement on small files.  Please direct
  478.     // questions about this implementation to ames!jaw.
  480.     int g_init_bits;
  482.     int ClearCode;
  483.     int EOFCode;
  485.     // output
  486.     //
  487.     // Output the given code.
  488.     // Inputs:
  489.     //      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
  490.     //              that n_bits =< wordsize - 1.
  491.     // Outputs:
  492.     //      Outputs code to the file.
  493.     // Assumptions:
  494.     //      Chars are 8 bits long.
  495.     // Algorithm:
  496.     //      Maintain a BITS character long buffer (so that 8 codes will
  497.     // fit in it exactly).  Use the VAX insv instruction to insert each
  498.     // code in turn.  When the buffer fills up empty it and start over.
  500.     int cur_accum = 0;
  501.     int cur_bits = 0;
  503.     int masks[] =
  504.             {
  506.                     0x0000,
  507.                     0x0001,
  508.                     0x0003,
  509.                     0x0007,
  510.                     0x000F,
  511.                     0x001F,
  512.                     0x003F,
  513.                     0x007F,
  514.                     0x00FF,
  515.                     0x01FF,
  516.                     0x03FF,
  517.                     0x07FF,
  518.                     0x0FFF,
  519.                     0x1FFF,
  520.                     0x3FFF,
  521.                     0x7FFF,
  522.                     0xFFFF};
  524.     // Number of characters so far in this 'packet'
  525.     int a_count;
  527.     // Define the storage for the packet accumulator
  528.     byte[] accum = new byte[256];
  530.     //----------------------------------------------------------------------------
  532.     /**
  533.      * @param width       宽度
  534.      * @param height      高度
  535.      * @param pixels      像素
  536.      * @param color_depth 颜色
  537.      */
  538.     Encoder(int width, int height, byte[] pixels, int color_depth) {
  540.         imgW = width;
  541.         imgH = height;
  542.         pixAry = pixels;
  543.         initCodeSize = Math.max(2, color_depth);
  544.     }
  546.     // Add a character to the end of the current packet, and if it is 254
  547.     // characters, flush the packet to disk.
  549.     /**
  550.      * @param c    字节
  551.      * @param outs 输出流
  552.      * @throws IOException IO异常
  553.      */
  554.     void char_out(byte c, OutputStream outs) throws IOException {
  556.         accum[a_count++] = c;
  557.         if (a_count >= 254)
  558.             flush_char(outs);
  559.     }
  561.     // Clear out the hash table
  563.     // table clear for block compress
  565.     /**
  566.      * @param outs 输出流
  567.      * @throws IOException IO异常
  568.      */
  569.     void cl_block(OutputStream outs) throws IOException {
  571.         cl_hash(hsize);
  572.         free_ent = ClearCode + 2;
  573.         clear_flg = true;
  575.         output(ClearCode, outs);
  576.     }
  578.     // reset code table
  580.     /**
  581.      * @param hsize int
  582.      */
  583.     void cl_hash(int hsize) {
  585.         for (int i = 0; i < hsize; ++i)
  586.             htab[i] = -1;
  587.     }
  589.     /**
  590.      * @param init_bits int
  591.      * @param outs      输出流
  592.      * @throws IOException IO异常
  593.      */
  594.     void compress(int init_bits, OutputStream outs) throws IOException {
  596.         int fcode;
  597.         int i /* = 0 */;
  598.         int c;
  599.         int ent;
  600.         int disp;
  601.         int hsize_reg;
  602.         int hshift;
  604.         // Set up the globals:  g_init_bits - initial number of bits
  605.         g_init_bits = init_bits;
  607.         // Set up the necessary values
  608.         clear_flg = false;
  609.         n_bits = g_init_bits;
  610.         maxcode = MAXCODE(n_bits);
  612.         ClearCode = 1 << (init_bits - 1);
  613.         EOFCode = ClearCode + 1;
  614.         free_ent = ClearCode + 2;
  616.         a_count = 0; // clear packet
  618.         ent = nextPixel();
  620.         hshift = 0;
  621.         for (fcode = hsize; fcode < 65536; fcode *= 2)
  622.             ++hshift;
  623.         hshift = 8 - hshift; // set hash code range bound
  625.         hsize_reg = hsize;
  626.         cl_hash(hsize_reg); // clear hash table
  628.         output(ClearCode, outs);
  630.         outer_loop:
  631.         while ((c = nextPixel()) != EOF) {
  633.             fcode = (c << maxbits) + ent;
  634.             i = (c << hshift) ^ ent; // xor hashing
  636.             if (htab[i] == fcode) {
  638.                 ent = codetab[i];
  639.                 continue;
  640.             } else if (htab[i] >= 0) // non-empty slot
  641.             {
  643.                 disp = hsize_reg - i; // secondary hash (after G. Knott)
  644.                 if (i == 0)
  645.                     disp = 1;
  646.                 do {
  648.                     if ((i -= disp) < 0)
  649.                         i += hsize_reg;
  651.                     if (htab[i] == fcode) {
  653.                         ent = codetab[i];
  654.                         continue outer_loop;
  655.                     }
  656.                 } while (htab[i] >= 0);
  657.             }
  658.             output(ent, outs);
  659.             ent = c;
  660.             if (free_ent < maxmaxcode) {
  662.                 codetab[i] = free_ent++; // code -> hashtable
  663.                 htab[i] = fcode;
  664.             } else
  665.                 cl_block(outs);
  666.         }
  667.         // Put out the final code.
  668.         output(ent, outs);
  669.         output(EOFCode, outs);
  670.     }
  672.     //----------------------------------------------------------------------------
  674.     /**
  675.      * @param os 输出流
  676.      * @throws IOException IO异常
  677.      */
  678.     void encode(OutputStream os) throws IOException {
  680.         os.write(initCodeSize); // write "initial code size" byte
  682.         remaining = imgW * imgH; // reset navigation variables
  683.         curPixel = 0;
  685.         compress(initCodeSize + 1, os); // compress and write the pixel data
  687.         os.write(0); // write block terminator
  688.     }
  690.     // Flush the packet to disk, and reset the accumulator
  692.     /**
  693.      * @param outs 输出流
  694.      * @throws IOException IO异常
  695.      */
  696.     void flush_char(OutputStream outs) throws IOException {
  698.         if (a_count > 0) {
  700.             outs.write(a_count);
  701.             outs.write(accum, 0, a_count);
  702.             a_count = 0;
  703.         }
  704.     }
  706.     /**
  707.      * @param n_bits int
  708.      * @return int
  709.      */
  710.     final int MAXCODE(int n_bits) {
  712.         return (1 << n_bits) - 1;
  713.     }
  715.     //----------------------------------------------------------------------------
  716.     // Return the next pixel from the image
  717.     //----------------------------------------------------------------------------
  719.     /**
  720.      * @return int
  721.      */
  722.     private int nextPixel() {
  724.         if (remaining == 0)
  725.             return EOF;
  727.         --remaining;
  729.         byte pix = pixAry[curPixel++];
  731.         return pix & 0xff;
  732.     }
  734.     /**
  735.      * @param code int
  736.      * @param outs 输出流
  737.      * @throws IOException IO异常
  738.      */
  739.     void output(int code, OutputStream outs) throws IOException {
  741.         cur_accum &= masks[cur_bits];
  743.         if (cur_bits > 0)
  744.             cur_accum |= (code << cur_bits);
  745.         else
  746.             cur_accum = code;
  748.         cur_bits += n_bits;
  750.         while (cur_bits >= 8) {
  752.             char_out((byte) (cur_accum & 0xff), outs);
  753.             cur_accum >>= 8;
  754.             cur_bits -= 8;
  755.         }
  757.         // If the next entry is going to be too big for the code size,
  758.         // then increase it, if possible.
  759.         if (free_ent > maxcode || clear_flg) {
  761.             if (clear_flg) {
  763.                 maxcode = MAXCODE(n_bits = g_init_bits);
  764.                 clear_flg = false;
  765.             } else {
  767.                 ++n_bits;
  768.                 if (n_bits == maxbits)
  769.                     maxcode = maxmaxcode;
  770.                 else
  771.                     maxcode = MAXCODE(n_bits);
  772.             }
  773.         }
  775.         if (code == EOFCode) {
  777.             // At EOF, write the rest of the buffer.
  778.             while (cur_bits > 0) {
  780.                 char_out((byte) (cur_accum & 0xff), outs);
  781.                 cur_accum >>= 8;
  782.                 cur_bits -= 8;
  783.             }
  785.             flush_char(outs);
  786.         }
  787.     }
  788. }
  790. public class Quant {
  792.     protected static final int netsize = 256; /* number of colours used */
  794.     /* four primes near 500 - assume no image has a length so large */
  795.     /* that it is divisible by all four primes */
  796.     protected static final int prime1 = 499;
  797.     protected static final int prime2 = 491;
  798.     protected static final int prime3 = 487;
  799.     protected static final int prime4 = 503;
  801.     protected static final int minpicturebytes = (3 * prime4);
  802.     /* minimum size for input image */
  804.     /* Program Skeleton
  805.        ----------------
  806.        [select samplefac in range 1..30]
  807.        [read image from input file]
  808.        pic = (unsigned char*) malloc(3*width*height);
  809.        initnet(pic,3*width*height,samplefac);
  810.        learn();
  811.        unbiasnet();
  812.        [write output image header, using writecolourmap(f)]
  813.        inxbuild();
  814.        write output image using inxsearch(b,g,r)      */
  816.     /* Network Definitions
  817.        ------------------- */
  819.     protected static final int maxnetpos = (netsize - 1);
  820.     protected static final int netbiasshift = 4; /* bias for colour values */
  821.     protected static final int ncycles = 100; /* no. of learning cycles */
  823.     /* defs for freq and bias */
  824.     protected static final int intbiasshift = 16; /* bias for fractions */
  825.     protected static final int intbias = (((int) 1) << intbiasshift);
  826.     protected static final int gammashift = 10; /* gamma = 1024 */
  827.     protected static final int gamma = (((int) 1) << gammashift);
  828.     protected static final int betashift = 10;
  829.     protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
  830.     protected static final int betagamma =
  831.             (intbias << (gammashift - betashift));
  833.     /* defs for decreasing radius factor */
  834.     protected static final int initrad = (netsize >> 3); /* for 256 cols, radius starts */
  835.     protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
  836.     protected static final int radiusbias = (((int) 1) << radiusbiasshift);
  837.     protected static final int initradius = (initrad * radiusbias); /* and decreases by a */
  838.     protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
  840.     /* defs for decreasing alpha factor */
  841.     protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
  842.     protected static final int initalpha = (((int) 1) << alphabiasshift);
  844.     protected int alphadec; /* biased by 10 bits */
  846.     /* radbias and alpharadbias used for radpower calculation */
  847.     protected static final int radbiasshift = 8;
  848.     protected static final int radbias = (((int) 1) << radbiasshift);
  849.     protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
  850.     protected static final int alpharadbias = (((int) 1) << alpharadbshift);
  852.     /* Types and Global Variables
  853.     -------------------------- */
  855.     protected byte[] thepicture; /* the input image itself */
  856.     protected int lengthcount; /* lengthcount = H*W*3 */
  858.     protected int samplefac; /* sampling factor 1..30 */
  860.     //   typedef int pixel[4];                /* BGRc */
  861.     protected int[][] network; /* the network itself - [netsize][4] */
  863.     protected int[] netindex = new int[256];
  864.     /* for network lookup - really 256 */
  866.     protected int[] bias = new int[netsize];
  867.     /* bias and freq arrays for learning */
  868.     protected int[] freq = new int[netsize];
  869.     protected int[] radpower = new int[initrad];
  870.     /* radpower for precomputation */
  872.     /* Initialise network in range (0,0,0) to (255,255,255) and set parameters
  873.        ----------------------------------------------------------------------- */
  874.     public Quant(byte[] thepic, int len, int sample) {
  877.         int i;
  878.         int[] p;
  880.         thepicture = thepic;
  881.         lengthcount = len;
  882.         samplefac = sample;
  884.         network = new int[netsize][];
  885.         for (i = 0; i < netsize; i++) {
  887.             network[i] = new int[4];
  888.             p = network[i];
  889.             p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
  890.             freq[i] = intbias / netsize; /* 1/netsize */
  891.             bias[i] = 0;
  892.         }
  893.     }
  895.     public byte[] colorMap() {
  897.         byte[] map = new byte[3 * netsize];
  898.         int[] index = new int[netsize];
  899.         for (int i = 0; i < netsize; i++)
  900.             index[network[i][3]] = i;
  901.         int k = 0;
  902.         for (int i = 0; i < netsize; i++) {
  904.             int j = index[i];
  905.             map[k++] = (byte) (network[j][0]);
  906.             map[k++] = (byte) (network[j][1]);
  907.             map[k++] = (byte) (network[j][2]);
  908.         }
  909.         return map;
  910.     }
  912.     /* Insertion sort of network and building of netindex[0..255] (to do after unbias)
  913.        ------------------------------------------------------------------------------- */
  914.     public void inxbuild() {
  917.         int i, j, smallpos, smallval;
  918.         int[] p;
  919.         int[] q;
  920.         int previouscol, startpos;
  922.         previouscol = 0;
  923.         startpos = 0;
  924.         for (i = 0; i < netsize; i++) {
  926.             p = network[i];
  927.             smallpos = i;
  928.             smallval = p[1]; /* index on g */
  929.             /* find smallest in i..netsize-1 */
  930.             for (j = i + 1; j < netsize; j++) {
  932.                 q = network[j];
  933.                 if (q[1] < smallval) {
  934.      /* index on g */
  935.                     smallpos = j;
  936.                     smallval = q[1]; /* index on g */
  937.                 }
  938.             }
  939.             q = network[smallpos];
  940.             /* swap p (i) and q (smallpos) entries */
  941.             if (i != smallpos) {
  943.                 j = q[0];
  944.                 q[0] = p[0];
  945.                 p[0] = j;
  946.                 j = q[1];
  947.                 q[1] = p[1];
  948.                 p[1] = j;
  949.                 j = q[2];
  950.                 q[2] = p[2];
  951.                 p[2] = j;
  952.                 j = q[3];
  953.                 q[3] = p[3];
  954.                 p[3] = j;
  955.             }
  956.             /* smallval entry is now in position i */
  957.             if (smallval != previouscol) {
  959.                 netindex[previouscol] = (startpos + i) >> 1;
  960.                 for (j = previouscol + 1; j < smallval; j++)
  961.                     netindex[j] = i;
  962.                 previouscol = smallval;
  963.                 startpos = i;
  964.             }
  965.         }
  966.         netindex[previouscol] = (startpos + maxnetpos) >> 1;
  967.         for (j = previouscol + 1; j < 256; j++)
  968.             netindex[j] = maxnetpos; /* really 256 */
  969.     }
  971.     /* Main Learning Loop
  972.        ------------------ */
  973.     public void learn() {
  976.         int i, j, b, g, r;
  977.         int radius, rad, alpha, step, delta, samplepixels;
  978.         byte[] p;
  979.         int pix, lim;
  981.         if (lengthcount < minpicturebytes)
  982.             samplefac = 1;
  983.         alphadec = 30 + ((samplefac - 1) / 3);
  984.         p = thepicture;
  985.         pix = 0;
  986.         lim = lengthcount;
  987.         samplepixels = lengthcount / (3 * samplefac);
  988.         delta = samplepixels / ncycles;
  989.         alpha = initalpha;
  990.         radius = initradius;
  992.         rad = radius >> radiusbiasshift;
  993.         if (rad <= 1)
  994.             rad = 0;
  995.         for (i = 0; i < rad; i++)
  996.             radpower[i] =
  997.                     alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
  999.         //fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
  1001.         if (lengthcount < minpicturebytes)
  1002.             step = 3;
  1003.         else if ((lengthcount % prime1) != 0)
  1004.             step = 3 * prime1;
  1005.         else {
  1007.             if ((lengthcount % prime2) != 0)
  1008.                 step = 3 * prime2;
  1009.             else {
  1011.                 if ((lengthcount % prime3) != 0)
  1012.                     step = 3 * prime3;
  1013.                 else
  1014.                     step = 3 * prime4;
  1015.             }
  1016.         }
  1018.         i = 0;
  1019.         while (i < samplepixels) {
  1021.             b = (p[pix + 0] & 0xff) << netbiasshift;
  1022.             g = (p[pix + 1] & 0xff) << netbiasshift;
  1023.             r = (p[pix + 2] & 0xff) << netbiasshift;
  1024.             j = contest(b, g, r);
  1026.             altersingle(alpha, j, b, g, r);
  1027.             if (rad != 0)
  1028.                 alterneigh(rad, j, b, g, r); /* alter neighbours */
  1030.             pix += step;
  1031.             if (pix >= lim)
  1032.                 pix -= lengthcount;
  1034.             i++;
  1035.             if (delta == 0)
  1036.                 delta = 1;
  1037.             if (i % delta == 0) {
  1039.                 alpha -= alpha / alphadec;
  1040.                 radius -= radius / radiusdec;
  1041.                 rad = radius >> radiusbiasshift;
  1042.                 if (rad <= 1)
  1043.                     rad = 0;
  1044.                 for (j = 0; j < rad; j++)
  1045.                     radpower[j] =
  1046.                             alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
  1047.             }
  1048.         }
  1049.         //fprintf(stderr,"finished 1D learning: final alpha=%f !\n",((float)alpha)/initalpha);
  1050.     }
  1052.     /* Search for BGR values 0..255 (after net is unbiased) and return colour index
  1053.        ---------------------------------------------------------------------------- */
  1054.     public int map(int b, int g, int r) {
  1057.         int i, j, dist, a, bestd;
  1058.         int[] p;
  1059.         int best;
  1061.         bestd = 1000; /* biggest possible dist is 256*3 */
  1062.         best = -1;
  1063.         i = netindex[g]; /* index on g */
  1064.         j = i - 1; /* start at netindex[g] and work outwards */
  1066.         while ((i < netsize) || (j >= 0)) {
  1068.             if (i < netsize) {
  1070.                 p = network[i];
  1071.                 dist = p[1] - g; /* inx key */
  1072.                 if (dist >= bestd)
  1073.                     i = netsize; /* stop iter */
  1074.                 else {
  1076.                     i++;
  1077.                     if (dist < 0)
  1078.                         dist = -dist;
  1079.                     a = p[0] - b;
  1080.                     if (a < 0)
  1081.                         a = -a;
  1082.                     dist += a;
  1083.                     if (dist < bestd) {
  1085.                         a = p[2] - r;
  1086.                         if (a < 0)
  1087.                             a = -a;
  1088.                         dist += a;
  1089.                         if (dist < bestd) {
  1091.                             bestd = dist;
  1092.                             best = p[3];
  1093.                         }
  1094.                     }
  1095.                 }
  1096.             }
  1097.             if (j >= 0) {
  1099.                 p = network[j];
  1100.                 dist = g - p[1]; /* inx key - reverse dif */
  1101.                 if (dist >= bestd)
  1102.                     j = -1; /* stop iter */
  1103.                 else {
  1105.                     j--;
  1106.                     if (dist < 0)
  1107.                         dist = -dist;
  1108.                     a = p[0] - b;
  1109.                     if (a < 0)
  1110.                         a = -a;
  1111.                     dist += a;
  1112.                     if (dist < bestd) {
  1114.                         a = p[2] - r;
  1115.                         if (a < 0)
  1116.                             a = -a;
  1117.                         dist += a;
  1118.                         if (dist < bestd) {
  1120.                             bestd = dist;
  1121.                             best = p[3];
  1122.                         }
  1123.                     }
  1124.                 }
  1125.             }
  1126.         }
  1127.         return (best);
  1128.     }
  1130.     public byte[] process() {
  1132.         learn();
  1133.         unbiasnet();
  1134.         inxbuild();
  1135.         return colorMap();
  1136.     }
  1138.     /* Unbias network to give byte values 0..255 and record position i to prepare for sort
  1139.        ----------------------------------------------------------------------------------- */
  1140.     public void unbiasnet() {
  1143.         int i, j;
  1145.         for (i = 0; i < netsize; i++) {
  1147.             network[i][0] >>= netbiasshift;
  1148.             network[i][1] >>= netbiasshift;
  1149.             network[i][2] >>= netbiasshift;
  1150.             network[i][3] = i; /* record colour no */
  1151.         }
  1152.     }
  1154.     /* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
  1155.        --------------------------------------------------------------------------------- */
  1156.     protected void alterneigh(int rad, int i, int b, int g, int r) {
  1159.         int j, k, lo, hi, a, m;
  1160.         int[] p;
  1162.         lo = i - rad;
  1163.         if (lo < -1)
  1164.             lo = -1;
  1165.         hi = i + rad;
  1166.         if (hi > netsize)
  1167.             hi = netsize;
  1169.         j = i + 1;
  1170.         k = i - 1;
  1171.         m = 1;
  1172.         while ((j < hi) || (k > lo)) {
  1174.             a = radpower[m++];
  1175.             if (j < hi) {
  1177.                 p = network[j++];
  1178.                 try {
  1180.                     p[0] -= (a * (p[0] - b)) / alpharadbias;
  1181.                     p[1] -= (a * (p[1] - g)) / alpharadbias;
  1182.                     p[2] -= (a * (p[2] - r)) / alpharadbias;
  1183.                 } catch (Exception e) {
  1185.                 } // prevents 1.3 miscompilation
  1186.             }
  1187.             if (k > lo) {
  1189.                 p = network[k--];
  1190.                 try {
  1192.                     p[0] -= (a * (p[0] - b)) / alpharadbias;
  1193.                     p[1] -= (a * (p[1] - g)) / alpharadbias;
  1194.                     p[2] -= (a * (p[2] - r)) / alpharadbias;
  1195.                 } catch (Exception e) {
  1197.                 }
  1198.             }
  1199.         }
  1200.     }
  1202.     /* Move neuron i towards biased (b,g,r) by factor alpha
  1203.        ---------------------------------------------------- */
  1204.     protected void altersingle(int alpha, int i, int b, int g, int r) {
  1207.         /* alter hit neuron */
  1208.         int[] n = network[i];
  1209.         n[0] -= (alpha * (n[0] - b)) / initalpha;
  1210.         n[1] -= (alpha * (n[1] - g)) / initalpha;
  1211.         n[2] -= (alpha * (n[2] - r)) / initalpha;
  1212.     }
  1214.     /* Search for biased BGR values
  1215.        ---------------------------- */
  1216.     protected int contest(int b, int g, int r) {
  1219.         /* finds closest neuron (min dist) and updates freq */
  1220.         /* finds best neuron (min dist-bias) and returns position */
  1221.         /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
  1222.         /* bias[i] = gamma*((1/netsize)-freq[i]) */
  1224.         int i, dist, a, biasdist, betafreq;
  1225.         int bestpos, bestbiaspos, bestd, bestbiasd;
  1226.         int[] n;
  1228.         bestd = ~(((int) 1) << 31);
  1229.         bestbiasd = bestd;
  1230.         bestpos = -1;
  1231.         bestbiaspos = bestpos;
  1233.         for (i = 0; i < netsize; i++) {
  1235.             n = network[i];
  1236.             dist = n[0] - b;
  1237.             if (dist < 0)
  1238.                 dist = -dist;
  1239.             a = n[1] - g;
  1240.             if (a < 0)
  1241.                 a = -a;
  1242.             dist += a;
  1243.             a = n[2] - r;
  1244.             if (a < 0)
  1245.                 a = -a;
  1246.             dist += a;
  1247.             if (dist < bestd) {
  1249.                 bestd = dist;
  1250.                 bestpos = i;
  1251.             }
  1252.             biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
  1253.             if (biasdist < bestbiasd) {
  1255.                 bestbiasd = biasdist;
  1256.                 bestbiaspos = i;
  1257.             }
  1258.             betafreq = (freq[i] >> betashift);
  1259.             freq[i] -= betafreq;
  1260.             bias[i] += (betafreq << gammashift);
  1261.         }
  1262.         freq[bestpos] += beta;
  1263.         bias[bestpos] -= betagamma;
  1264.         return (bestbiaspos);
  1265.     }
  1266. }
  1268. import java.awt.*;
  1269. import java.awt.image.BufferedImage;
  1270. import java.awt.image.DataBufferByte;
  1271. import java.io.*;
  1274. /**
  1275.  * Gif生成工具
  1276.  * Class AnimatedGifEncoder - Encodes a GIF file consisting of one or
  1277.  * more frames.
  1278.  * <pre>
  1279.  * Example:
  1280.  *    AnimatedGifEncoder e = new AnimatedGifEncoder();
  1281.  *    e.start(outputFileName);
  1282.  *    e.setDelay(1000);   // 1 frame per sec
  1283.  *    e.addFrame(image1);
  1284.  *    e.addFrame(image2);
  1285.  *    e.finish();
  1286.  * </pre>
  1287.  * No copyright asserted on the source code of this class.  May be used
  1288.  * for any purpose, however, refer to the Unisys LZW patent for restrictions
  1289.  * on use of the associated Encoder class.  Please forward any corrections
  1290.  * to questions at fmsware.com.
  1291.  */
  1292. public class GifEncoder {
  1294.     protected int width; // image size
  1295.     protected int height;
  1296.     protected Color transparent = null; // transparent color if given
  1297.     protected int transIndex; // transparent index in color table
  1298.     protected int repeat = -1; // no repeat
  1299.     protected int delay = 0; // frame delay (hundredths)
  1300.     protected boolean started = false; // ready to output frames
  1301.     protected OutputStream out;
  1302.     protected BufferedImage image; // current frame
  1303.     protected byte[] pixels; // BGR byte array from frame
  1304.     protected byte[] indexedPixels; // converted frame indexed to palette
  1305.     protected int colorDepth; // number of bit planes
  1306.     protected byte[] colorTab; // RGB palette
  1307.     protected boolean[] usedEntry = new boolean[256]; // active palette entries
  1308.     protected int palSize = 7; // color table size (bits-1)
  1309.     protected int dispose = -1; // disposal code (-1 = use default)
  1310.     protected boolean closeStream = false; // close stream when finished
  1311.     protected boolean firstFrame = true;
  1312.     protected boolean sizeSet = false; // if false, get size from first frame
  1313.     protected int sample = 10; // default sample interval for quantizer
  1315.     /**
  1316.      * Sets the delay time between each frame, or changes it
  1317.      * for subsequent frames (applies to last frame added).
  1318.      *
  1319.      * @param ms int delay time in milliseconds
  1320.      */
  1321.     public void setDelay(int ms) {
  1323.         delay = Math.round(ms / 10.0f);
  1324.     }
  1326.     /**
  1327.      * Sets the GIF frame disposal code for the last added frame
  1328.      * and any subsequent frames.  Default is 0 if no transparent
  1329.      * color has been set, otherwise 2.
  1330.      *
  1331.      * @param code int disposal code.
  1332.      */
  1333.     public void setDispose(int code) {
  1335.         if (code >= 0) {
  1337.             dispose = code;
  1338.         }
  1339.     }
  1341.     /**
  1342.      * Sets the number of times the set of GIF frames
  1343.      * should be played.  Default is 1; 0 means play
  1344.      * indefinitely.  Must be invoked before the first
  1345.      * image is added.
  1346.      *
  1347.      * @param iter int number of iterations.
  1348.      */
  1349.     public void setRepeat(int iter) {
  1351.         if (iter >= 0) {
  1353.             repeat = iter;
  1354.         }
  1355.     }
  1357.     /**
  1358.      * Sets the transparent color for the last added frame
  1359.      * and any subsequent frames.
  1360.      * Since all colors are subject to modification
  1361.      * in the quantization process, the color in the final
  1362.      * palette for each frame closest to the given color
  1363.      * becomes the transparent color for that frame.
  1364.      * May be set to null to indicate no transparent color.
  1365.      *
  1366.      * @param c Color to be treated as transparent on display.
  1367.      */
  1368.     public void setTransparent(Color c) {
  1370.         transparent = c;
  1371.     }
  1373.     /**
  1374.      * Adds next GIF frame.  The frame is not written immediately, but is
  1375.      * actually deferred until the next frame is received so that timing
  1376.      * data can be inserted.  Invoking <code>finish()</code> flushes all
  1377.      * frames.  If <code>setSize</code> was not invoked, the size of the
  1378.      * first image is used for all subsequent frames.
  1379.      *
  1380.      * @param im BufferedImage containing frame to write.
  1381.      * @return true if successful.
  1382.      */
  1383.     public boolean addFrame(BufferedImage im) {
  1385.         if ((im == null) || !started) {
  1387.             return false;
  1388.         }
  1389.         boolean ok = true;
  1390.         try {
  1392.             if (!sizeSet) {
  1394.                 // use first frame's size
  1395.                 setSize(im.getWidth(), im.getHeight());
  1396.             }
  1397.             image = im;
  1398.             getImagePixels(); // convert to correct format if necessary
  1399.             analyzePixels(); // build color table & map pixels
  1400.             if (firstFrame) {
  1402.                 writeLSD(); // logical screen descriptior
  1403.                 writePalette(); // global color table
  1404.                 if (repeat >= 0) {
  1406.                     // use NS app extension to indicate reps
  1407.                     writeNetscapeExt();
  1408.                 }
  1409.             }
  1410.             writeGraphicCtrlExt(); // write graphic control extension
  1411.             writeImageDesc(); // image descriptor
  1412.             if (!firstFrame) {
  1414.                 writePalette(); // local color table
  1415.             }
  1416.             writePixels(); // encode and write pixel data
  1417.             firstFrame = false;
  1418.         } catch (IOException e) {
  1420.             ok = false;
  1421.         }
  1423.         return ok;
  1424.     }
  1426.     //added by alvaro
  1427.     public boolean outFlush() {
  1429.         boolean ok = true;
  1430.         try {
  1432.             out.flush();
  1433.             return ok;
  1434.         } catch (IOException e) {
  1436.             ok = false;
  1437.         }
  1439.         return ok;
  1440.     }
  1442.     public byte[] getFrameByteArray() {
  1444.         return ((ByteArrayOutputStream) out).toByteArray();
  1445.     }
  1447.     /**
  1448.      * Flushes any pending data and closes output file.
  1449.      * If writing to an OutputStream, the stream is not
  1450.      * closed.
  1451.      *
  1452.      * @return boolean
  1453.      */
  1454.     public boolean finish() {
  1456.         if (!started) return false;
  1457.         boolean ok = true;
  1458.         started = false;
  1459.         try {
  1461.             out.write(0x3b); // gif trailer
  1462.             out.flush();
  1463.             if (closeStream) {
  1465.                 out.close();
  1466.             }
  1467.         } catch (IOException e) {
  1469.             ok = false;
  1470.         }
  1472.         return ok;
  1473.     }
  1475.     public void reset() {
  1477.         // reset for subsequent use
  1478.         transIndex = 0;
  1479.         out = null;
  1480.         image = null;
  1481.         pixels = null;
  1482.         indexedPixels = null;
  1483.         colorTab = null;
  1484.         closeStream = false;
  1485.         firstFrame = true;
  1486.     }
  1488.     /**
  1489.      * Sets frame rate in frames per second.  Equivalent to
  1490.      * <code>setDelay(1000/fps)</code>.
  1491.      *
  1492.      * @param fps float frame rate (frames per second)
  1493.      */
  1494.     public void setFrameRate(float fps) {
  1496.         if (fps != 0f) {
  1498.             delay = Math.round(100f / fps);
  1499.         }
  1500.     }
  1502.     /**
  1503.      * Sets quality of color quantization (conversion of images
  1504.      * to the maximum 256 colors allowed by the GIF specification).
  1505.      * Lower values (minimum = 1) produce better colors, but slow
  1506.      * processing significantly.  10 is the default, and produces
  1507.      * good color mapping at reasonable speeds.  Values greater
  1508.      * than 20 do not yield significant improvements in speed.
  1509.      *
  1510.      * @param quality int greater than 0.
  1511.      */
  1512.     public void setQuality(int quality) {
  1514.         if (quality < 1) quality = 1;
  1515.         sample = quality;
  1516.     }
  1518.     /**
  1519.      * Sets the GIF frame size.  The default size is the
  1520.      * size of the first frame added if this method is
  1521.      * not invoked.
  1522.      *
  1523.      * @param w int frame width.
  1524.      * @param h int frame width.
  1525.      */
  1526.     public void setSize(int w, int h) {
  1528.         if (started && !firstFrame) return;
  1529.         width = w;
  1530.         height = h;
  1531.         if (width < 1) width = 320;
  1532.         if (height < 1) height = 240;
  1533.         sizeSet = true;
  1534.     }
  1536.     /**
  1537.      * Initiates GIF file creation on the given stream.  The stream
  1538.      * is not closed automatically.
  1539.      *
  1540.      * @param os OutputStream on which GIF images are written.
  1541.      * @return false if initial write failed.
  1542.      */
  1543.     public boolean start(OutputStream os) {
  1545.         if (os == null) return false;
  1546.         boolean ok = true;
  1547.         closeStream = false;
  1548.         out = os;
  1549.         try {
  1551.             writeString("GIF89a"); // header
  1552.         } catch (IOException e) {
  1554.             ok = false;
  1555.         }
  1556.         return started = ok;
  1557.     }
  1559.     /**
  1560.      * Initiates writing of a GIF file with the specified name.
  1561.      *
  1562.      * @param file String containing output file name.
  1563.      * @return false if open or initial write failed.
  1564.      */
  1565.     public boolean start(String file) {
  1567.         boolean ok = true;
  1568.         try {
  1570.             out = new BufferedOutputStream(new FileOutputStream(file));
  1571.             ok = start(out);
  1572.             closeStream = true;
  1573.         } catch (IOException e) {
  1575.             ok = false;
  1576.         }
  1577.         return started = ok;
  1578.     }
  1580.     /**
  1581.      * Analyzes image colors and creates color map.
  1582.      */
  1583.     protected void analyzePixels() {
  1585.         int len = pixels.length;
  1586.         int nPix = len / 3;
  1587.         indexedPixels = new byte[nPix];
  1588.         Quant nq = new Quant(pixels, len, sample);
  1589.         // initialize quantizer
  1590.         colorTab = nq.process(); // create reduced palette
  1591.         // convert map from BGR to RGB
  1592.         for (int i = 0; i < colorTab.length; i += 3) {
  1594.             byte temp = colorTab[i];
  1595.             colorTab[i] = colorTab[i + 2];
  1596.             colorTab[i + 2] = temp;
  1597.             usedEntry[i / 3] = false;
  1598.         }
  1599.         // map image pixels to new palette
  1600.         int k = 0;
  1601.         for (int i = 0; i < nPix; i++) {
  1603.             int index =
  1604.                     nq.map(pixels[k++] & 0xff,
  1605.                             pixels[k++] & 0xff,
  1606.                             pixels[k++] & 0xff);
  1607.             usedEntry[index] = true;
  1608.             indexedPixels[i] = (byte) index;
  1609.         }
  1610.         pixels = null;
  1611.         colorDepth = 8;
  1612.         palSize = 7;
  1613.         // get closest match to transparent color if specified
  1614.         if (transparent != null) {
  1616.             transIndex = findClosest(transparent);
  1617.         }
  1618.     }
  1620.     /**
  1621.      * Returns index of palette color closest to c
  1622.      *
  1623.      * @param c color
  1624.      * @return int
  1625.      */
  1626.     protected int findClosest(Color c) {
  1628.         if (colorTab == null) return -1;
  1629.         int r = c.getRed();
  1630.         int g = c.getGreen();
  1631.         int b = c.getBlue();
  1632.         int minpos = 0;
  1633.         int dmin = 256 * 256 * 256;
  1634.         int len = colorTab.length;
  1635.         for (int i = 0; i < len; ) {
  1637.             int dr = r - (colorTab[i++] & 0xff);
  1638.             int dg = g - (colorTab[i++] & 0xff);
  1639.             int db = b - (colorTab[i] & 0xff);
  1640.             int d = dr * dr + dg * dg + db * db;
  1641.             int index = i / 3;
  1642.             if (usedEntry[index] && (d < dmin)) {
  1644.                 dmin = d;
  1645.                 minpos = index;
  1646.             }
  1647.             i++;
  1648.         }
  1649.         return minpos;
  1650.     }
  1652.     /**
  1653.      * Extracts image pixels into byte array "pixels"
  1654.      */
  1655.     protected void getImagePixels() {
  1657.         int w = image.getWidth();
  1658.         int h = image.getHeight();
  1659.         int type = image.getType();
  1660.         if ((w != width)
  1661.                 || (h != height)
  1662.                 || (type != BufferedImage.TYPE_3BYTE_BGR)) {
  1664.             // create new image with right size/format
  1665.             BufferedImage temp =
  1666.                     new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
  1667.             Graphics2D g = temp.createGraphics();
  1668.             g.drawImage(image, 0, 0, null);
  1669.             image = temp;
  1670.         }
  1671.         pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
  1672.     }
  1674.     /**
  1675.      * Writes Graphic Control Extension
  1676.      *
  1677.      * @throws IOException IO异常
  1678.      */
  1679.     protected void writeGraphicCtrlExt() throws IOException {
  1681.         out.write(0x21); // extension introducer
  1682.         out.write(0xf9); // GCE label
  1683.         out.write(4); // data block size
  1684.         int transp, disp;
  1685.         if (transparent == null) {
  1687.             transp = 0;
  1688.             disp = 0; // dispose = no action
  1689.         } else {
  1691.             transp = 1;
  1692.             disp = 2; // force clear if using transparent color
  1693.         }
  1694.         if (dispose >= 0) {
  1696.             disp = dispose & 7; // user override
  1697.         }
  1698.         disp <<= 2;
  1700.         // packed fields
  1701.         out.write(0 | // 1:3 reserved
  1702.                 disp | // 4:6 disposal
  1703.                 0 | // 7   user input - 0 = none
  1704.                 transp); // 8   transparency flag
  1706.         writeShort(delay); // delay x 1/100 sec
  1707.         out.write(transIndex); // transparent color index
  1708.         out.write(0); // block terminator
  1709.     }
  1711.     /**
  1712.      * Writes Image Descriptor
  1713.      *
  1714.      * @throws IOException IO异常
  1715.      */
  1716.     protected void writeImageDesc() throws IOException {
  1718.         out.write(0x2c); // image separator
  1719.         writeShort(0); // image position x,y = 0,0
  1720.         writeShort(0);
  1721.         writeShort(width); // image size
  1722.         writeShort(height);
  1723.         // packed fields
  1724.         if (firstFrame) {
  1726.             // no LCT  - GCT is used for first (or only) frame
  1727.             out.write(0);
  1728.         } else {
  1730.             // specify normal LCT
  1731.             out.write(0x80 | // 1 local color table  1=yes
  1732.                     0 | // 2 interlace - 0=no
  1733.                     0 | // 3 sorted - 0=no
  1734.                     0 | // 4-5 reserved
  1735.                     palSize); // 6-8 size of color table
  1736.         }
  1737.     }
  1739.     /**
  1740.      * Writes Logical Screen Descriptor
  1741.      *
  1742.      * @throws IOException IO异常
  1743.      */
  1744.     protected void writeLSD() throws IOException {
  1746.         // logical screen size
  1747.         writeShort(width);
  1748.         writeShort(height);
  1749.         // packed fields
  1750.         out.write((0x80 | // 1   : global color table flag = 1 (gct used)
  1751.                 0x70 | // 2-4 : color resolution = 7
  1752.                 0x00 | // 5   : gct sort flag = 0
  1753.                 palSize)); // 6-8 : gct size
  1755.         out.write(0); // background color index
  1756.         out.write(0); // pixel aspect ratio - assume 1:1
  1757.     }
  1759.     /**
  1760.      * Writes Netscape application extension to define
  1761.      * repeat count.
  1762.      *
  1763.      * @throws IOException IO异常
  1764.      */
  1765.     protected void writeNetscapeExt() throws IOException {
  1767.         out.write(0x21); // extension introducer
  1768.         out.write(0xff); // app extension label
  1769.         out.write(11); // block size
  1770.         writeString("NETSCAPE" + "2.0"); // app id + auth code
  1771.         out.write(3); // sub-block size
  1772.         out.write(1); // loop sub-block id
  1773.         writeShort(repeat); // loop count (extra iterations, 0=repeat forever)
  1774.         out.write(0); // block terminator
  1775.     }
  1777.     /**
  1778.      * Writes color table
  1779.      *
  1780.      * @throws IOException IO异常
  1781.      */
  1782.     protected void writePalette() throws IOException {
  1784.         out.write(colorTab, 0, colorTab.length);
  1785.         int n = (3 * 256) - colorTab.length;
  1786.         for (int i = 0; i < n; i++) {
  1788.             out.write(0);
  1789.         }
  1790.     }
  1792.     /**
  1793.      * Encodes and writes pixel data
  1794.      *
  1795.      * @throws IOException IO异常
  1796.      */
  1797.     protected void writePixels() throws IOException {
  1799.         Encoder encoder = new Encoder(width, height, indexedPixels, colorDepth);
  1800.         encoder.encode(out);
  1801.     }
  1803.     /**
  1804.      * Write 16-bit value to output stream, LSB first
  1805.      *
  1806.      * @param value int
  1807.      * @throws IOException IO异常
  1808.      */
  1809.     protected void writeShort(int value) throws IOException {
  1811.         out.write(value & 0xff);
  1812.         out.write((value >> 8) & 0xff);
  1813.     }
  1815.     /**
  1816.      * Writes string to output stream
  1817.      *
  1818.      * @param s string
  1819.      * @throws IOException IO异常
  1820.      */
  1821.     protected void writeString(String s) throws IOException {
  1823.         for (int i = 0; i < s.length(); i++) {
  1825.             out.write((byte) s.charAt(i));
  1826.         }
  1827.     }
  1828. }

[Image 1]:

发表评论

表情：
评论列表 （有 0 条评论，173人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java生成图片验证码

    功能介绍：自定义图片尺寸和字符长度，随机背景颜色和字符颜色，随机字符偏移角度，字符平滑边缘，干扰线，噪点，背景扭曲。 VerifyCodeUtils类，生成图片流，然后不同框

    素颜马尾好姑娘i素颜马尾好姑娘i/ 0 赞/ 388 阅读

    相关 动态生成验证码

    动态生成验证码在很多地方可以用到，最近在学习牛腩视频的时候，正好看到了，就此简单总结一下。 为了简单方便，我们新建一个验证码测试的项目名为test，然后在项目中新建一个文件夹

    刺骨的言语ヽ痛彻心扉刺骨的言语ヽ痛彻心扉/ 0 赞/ 296 阅读

    相关 生成图片验证码

    问题描述 在项目中遇到有人恶意拉取图片资源，无限刷资源，导致阿里图片服务器流量暴涨(钱遭不住),使得带宽一直处于上限，正常用户不能好的访问。 解决办法 这个功能设

    左手的ㄟ右手左手的ㄟ右手/ 0 赞/ 487 阅读