JAVA生成GIF图片

 前面写了利用java合并图片的文章，一位朋友说应该把gif图片不失真的合并起来，自己想想也是，可是自己技术还没过关，所以没有找到解决方法，于是上网GOOGLE一番，以外发现了一套java生成gif图片的方法，现在贴上来，跟大家共同学习。

  先看一下效果图：

  

 

主方法:

1. import com.sun.image.codec.jpeg.*;
2. import com.sun.image.codec.*;
3. import javax.imageio.*;
4. import java.awt.*;
5. import java.io.*;
6. import java.awt.image.*;
7. public class DrawImage{
8.     public static void main(String[] args) throws Exception{
9.         
10.         
11.         try{ 
12.             BufferedImage src = ImageIO.read(new File("Img221785570.jpg")); // ¶ÁÈëÎļþ 
13.             BufferedImage src1 = ImageIO.read(new File("W.gif")); // ¶ÁÈëÎļþ 
14.             //BufferedImage src2 = ImageIO.read(new File("c:/ship3.jpg")); // ¶ÁÈëÎļþ 
15.             AnimatedGifEncoder e = new AnimatedGifEncoder(); 
16.             e.setRepeat(0); 
17.             e.start("laoma.gif"); 
18.             e.setDelay(300); // 1 frame per sec 
19.             e.addFrame(src); 
20.             e.setDelay(100); 
21.             e.addFrame(src1); 
22.             e.setDelay(100); 
23.         //  e.addFrame(src2); 
24.             e.finish(); 
26.         }catch(IOException e){ 
27.         e.printStackTrace(); 
28.         } 
30.     }
31. }

其中有两个关键类:

1. import java.io.*;
2. import java.awt.*;
3. import java.awt.image.*;
5. /**
6.  * Class AnimatedGifEncoder - Encodes a GIF file consisting of one or
7.  * more frames.
8.  * <pre>
9.  * Example:
10.  *    AnimatedGifEncoder e = new AnimatedGifEncoder();
11.  *    e.start(outputFileName);
12.  *    e.setDelay(1000);   // 1 frame per sec
13.  *    e.addFrame(image1);
14.  *    e.addFrame(image2);
15.  *    e.finish();
16.  * </pre>
17.  * No copyright asserted on the source code of this class.  May be used
18.  * for any purpose, however, refer to the Unisys LZW patent for restrictions
19.  * on use of the associated LZWEncoder class.  Please forward any corrections
20.  * to [e-mail].
21.  *
22.  * @author Kevin Weiner, FM Software
23.  * @version 1.03 November 2003
24.  *
25.  */
27. public class AnimatedGifEncoder {
29.  protected int width; // image size
30.  protected int height;
31.  protected Color transparent = null; // transparent color if given
32.  protected int transIndex; // transparent index in color table
33.  protected int repeat = -1; // no repeat
34.  protected int delay = 0; // frame delay (hundredths)
35.  protected boolean started = false; // ready to output frames
36.  protected OutputStream out;
37.  protected BufferedImage image; // current frame
38.  protected byte[] pixels; // BGR byte array from frame
39.  protected byte[] indexedPixels; // converted frame indexed to palette
40.  protected int colorDepth; // number of bit planes
41.  protected byte[] colorTab; // RGB palette
42.  protected boolean[] usedEntry = new boolean[256]; // active palette entries
43.  protected int palSize = 7; // color table size (bits-1)
44.  protected int dispose = -1; // disposal code (-1 = use default)
45.  protected boolean closeStream = false; // close stream when finished
46.  protected boolean firstFrame = true;
47.  protected boolean sizeSet = false; // if false, get size from first frame
48.  protected int sample = 10; // default sample interval for quantizer
50.  /**
51.   * Sets the delay time between each frame, or changes it
52.   * for subsequent frames (applies to last frame added).
53.   *
54.   * @param ms int delay time in milliseconds
55.   */
56.  public void setDelay(int ms) {
57.   delay = Math.round(ms / 10.0f);
58.  }
60.  /**
61.   * Sets the GIF frame disposal code for the last added frame
62.   * and any subsequent frames.  Default is 0 if no transparent
63.   * color has been set, otherwise 2.
64.   * @param code int disposal code.
65.   */
66.  public void setDispose(int code) {
67.   if (code >= 0) {
68.    dispose = code;
69.   }
70.  }
72.  /**
73.   * Sets the number of times the set of GIF frames
74.   * should be played.  Default is 1; 0 means play
75.   * indefinitely.  Must be invoked before the first
76.   * image is added.
77.   *
78.   * @param iter int number of iterations.
79.   * @return
80.   */
81.  public void setRepeat(int iter) {
82.   if (iter >= 0) {
83.    repeat = iter;
84.   }
85.  }
87.  /**
88.   * Sets the transparent color for the last added frame
89.   * and any subsequent frames.
90.   * Since all colors are subject to modification
91.   * in the quantization process, the color in the final
92.   * palette for each frame closest to the given color
93.   * becomes the transparent color for that frame.
94.   * May be set to null to indicate no transparent color.
95.   *
96.   * @param c Color to be treated as transparent on display.
97.   */
98.  public void setTransparent(Color c) {
99.   transparent = c;
100.  }
102.  /**
103.   * Adds next GIF frame.  The frame is not written immediately, but is
104.   * actually deferred until the next frame is received so that timing
105.   * data can be inserted.  Invoking <code>finish()</code> flushes all
106.   * frames.  If <code>setSize</code> was not invoked, the size of the
107.   * first image is used for all subsequent frames.
108.   *
109.   * @param im BufferedImage containing frame to write.
110.   * @return true if successful.
111.   */
112.  public boolean addFrame(BufferedImage im) {
113.   if ((im == null) || !started) {
114.    return false;
115.   }
116.   boolean ok = true;
117.   try {
118.    if (!sizeSet) {
119.     // use first frame's size
120.     setSize(im.getWidth(), im.getHeight());
121.    }
122.    image = im;
123.    getImagePixels(); // convert to correct format if necessary
124.    analyzePixels(); // build color table & map pixels
125.    if (firstFrame) {
126.     writeLSD(); // logical screen descriptior
127.     writePalette(); // global color table
128.     if (repeat >= 0) {
129.      // use NS app extension to indicate reps
130.      writeNetscapeExt();
131.     }
132.    }
133.    writeGraphicCtrlExt(); // write graphic control extension
134.    writeImageDesc(); // image descriptor
135.    if (!firstFrame) {
136.     writePalette(); // local color table
137.    }
138.    writePixels(); // encode and write pixel data
139.    firstFrame = false;
140.   } catch (IOException e) {
141.    ok = false;
142.   }
144.   return ok;
145.  }
147.  /**
148.   * Flushes any pending data and closes output file.
149.   * If writing to an OutputStream, the stream is not
150.   * closed.
151.   */
152.  public boolean finish() {
153.   if (!started) return false;
154.   boolean ok = true;
155.   started = false;
156.   try {
157.    out.write(0x3b); // gif trailer
158.    out.flush();
159.    if (closeStream) {
160.     out.close();
161.    }
162.   } catch (IOException e) {
163.    ok = false;
164.   }
166.   // reset for subsequent use
167.   transIndex = 0;
168.   out = null;
169.   image = null;
170.   pixels = null;
171.   indexedPixels = null;
172.   colorTab = null;
173.   closeStream = false;
174.   firstFrame = true;
176.   return ok;
177.  }
179.  /**
180.   * Sets frame rate in frames per second.  Equivalent to
181.   * <code>setDelay(1000/fps)</code>.
182.   *
183.   * @param fps float frame rate (frames per second)
184.   */
185.  public void setFrameRate(float fps) {
186.   if (fps != 0f) {
187.    delay = Math.round(100f / fps);
188.   }
189.  }
191.  /**
192.   * Sets quality of color quantization (conversion of images
193.   * to the maximum 256 colors allowed by the GIF specification).
194.   * Lower values (minimum = 1) produce better colors, but slow
195.   * processing significantly.  10 is the default, and produces
196.   * good color mapping at reasonable speeds.  Values greater
197.   * than 20 do not yield significant improvements in speed.
198.   *
199.   * @param quality int greater than 0.
200.   * @return
201.   */
202.  public void setQuality(int quality) {
203.   if (quality < 1) quality = 1;
204.   sample = quality;
205.  }
207.  /**
208.   * Sets the GIF frame size.  The default size is the
209.   * size of the first frame added if this method is
210.   * not invoked.
211.   *
212.   * @param w int frame width.
213.   * @param h int frame width.
214.   */
215.  public void setSize(int w, int h) {
216.   if (started && !firstFrame) return;
217.   width = w;
218.   height = h;
219.   if (width < 1) width = 320;
220.   if (height < 1) height = 240;
221.   sizeSet = true;
222.  }
224.  /**
225.   * Initiates GIF file creation on the given stream.  The stream
226.   * is not closed automatically.
227.   *
228.   * @param os OutputStream on which GIF images are written.
229.   * @return false if initial write failed.
230.   */
231.  public boolean start(OutputStream os) {
232.   if (os == null) return false;
233.   boolean ok = true;
234.   closeStream = false;
235.   out = os;
236.   try {
237.    writeString("GIF89a"); // header
238.   } catch (IOException e) {
239.    ok = false;
240.   }
241.   return started = ok;
242.  }
244.  /**
245.   * Initiates writing of a GIF file with the specified name.
246.   *
247.   * @param file String containing output file name.
248.   * @return false if open or initial write failed.
249.   */
250.  public boolean start(String file) {
251.   boolean ok = true;
252.   try {
253.    out = new BufferedOutputStream(new FileOutputStream(file));
254.    ok = start(out);
255.    closeStream = true;
256.   } catch (IOException e) {
257.    ok = false;
258.   }
259.   return started = ok;
260.  }
262.  /**
263.   * Analyzes image colors and creates color map.
264.   */
265.  protected void analyzePixels() {
266.   int len = pixels.length;
267.   int nPix = len / 3;
268.   indexedPixels = new byte[nPix];
269.   NeuQuant nq = new NeuQuant(pixels, len, sample);
270.   // initialize quantizer
271.   colorTab = nq.process(); // create reduced palette
272.   // convert map from BGR to RGB
273.   for (int i = 0; i < colorTab.length; i += 3) {
274.    byte temp = colorTab[i];
275.    colorTab[i] = colorTab[i + 2];
276.    colorTab[i + 2] = temp;
277.    usedEntry[i / 3] = false;
278.   }
279.   // map image pixels to new palette
280.   int k = 0;
281.   for (int i = 0; i < nPix; i++) {
282.    int index =
283.     nq.map(pixels[k++] & 0xff,
284.         pixels[k++] & 0xff,
285.         pixels[k++] & 0xff);
286.    usedEntry[index] = true;
287.    indexedPixels[i] = (byte) index;
288.   }
289.   pixels = null;
290.   colorDepth = 8;
291.   palSize = 7;
292.   // get closest match to transparent color if specified
293.   if (transparent != null) {
294.    transIndex = findClosest(transparent);
295.   }
296.  }
298.  /**
299.   * Returns index of palette color closest to c
300.   *
301.   */
302.  protected int findClosest(Color c) {
303.   if (colorTab == null) return -1;
304.   int r = c.getRed();
305.   int g = c.getGreen();
306.   int b = c.getBlue();
307.   int minpos = 0;
308.   int dmin = 256 * 256 * 256;
309.   int len = colorTab.length;
310.   for (int i = 0; i < len;) {
311.    int dr = r - (colorTab[i++] & 0xff);
312.    int dg = g - (colorTab[i++] & 0xff);
313.    int db = b - (colorTab[i] & 0xff);
314.    int d = dr * dr + dg * dg + db * db;
315.    int index = i / 3;
316.    if (usedEntry[index] && (d < dmin)) {
317.     dmin = d;
318.     minpos = index;
319.    }
320.    i++;
321.   }
322.   return minpos;
323.  }
325.  /**
326.   * Extracts image pixels into byte array "pixels"
327.   */
328.  protected void getImagePixels() {
329.   int w = image.getWidth();
330.   int h = image.getHeight();
331.   int type = image.getType();
332.   if ((w != width)
333.    || (h != height)
334.    || (type != BufferedImage.TYPE_3BYTE_BGR)) {
335.    // create new image with right size/format
336.    BufferedImage temp =
337.     new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
338.    Graphics2D g = temp.createGraphics();
339.    g.drawImage(image, 0, 0, null);
340.    image = temp;
341.   }
342.   pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
343.  }
345.  /**
346.   * Writes Graphic Control Extension
347.   */
348.  protected void writeGraphicCtrlExt() throws IOException {
349.   out.write(0x21); // extension introducer
350.   out.write(0xf9); // GCE label
351.   out.write(4); // data block size
352.   int transp, disp;
353.   if (transparent == null) {
354.    transp = 0;
355.    disp = 0; // dispose = no action
356.   } else {
357.    transp = 1;
358.    disp = 2; // force clear if using transparent color
359.   }
360.   if (dispose >= 0) {
361.    disp = dispose & 7; // user override
362.   }
363.   disp <<= 2;
365.   // packed fields
366.   out.write(0 | // 1:3 reserved
367.       disp | // 4:6 disposal
368.          0 | // 7   user input - 0 = none
369.        transp); // 8   transparency flag
371.   writeShort(delay); // delay x 1/100 sec
372.   out.write(transIndex); // transparent color index
373.   out.write(0); // block terminator
374.  }
376.  /**
377.   * Writes Image Descriptor
378.   */
379.  protected void writeImageDesc() throws IOException {
380.   out.write(0x2c); // image separator
381.   writeShort(0); // image position x,y = 0,0
382.   writeShort(0);
383.   writeShort(width); // image size
384.   writeShort(height);
385.   // packed fields
386.   if (firstFrame) {
387.    // no LCT  - GCT is used for first (or only) frame
388.    out.write(0);
389.   } else {
390.    // specify normal LCT
391.    out.write(0x80 | // 1 local color table  1=yes
392.        0 | // 2 interlace - 0=no
393.        0 | // 3 sorted - 0=no
394.        0 | // 4-5 reserved
395.        palSize); // 6-8 size of color table
396.   }
397.  }
399.  /**
400.   * Writes Logical Screen Descriptor
401.   */
402.  protected void writeLSD() throws IOException {
403.   // logical screen size
404.   writeShort(width);
405.   writeShort(height);
406.   // packed fields
407.   out.write((0x80 | // 1   : global color table flag = 1 (gct used)
408.        0x70 | // 2-4 : color resolution = 7
409.        0x00 | // 5   : gct sort flag = 0
410.       palSize)); // 6-8 : gct size
412.   out.write(0); // background color index
413.   out.write(0); // pixel aspect ratio - assume 1:1
414.  }
416.  /**
417.   * Writes Netscape application extension to define
418.   * repeat count.
419.   */
420.  protected void writeNetscapeExt() throws IOException {
421.   out.write(0x21); // extension introducer
422.   out.write(0xff); // app extension label
423.   out.write(11); // block size
424.   writeString("NETSCAPE" + "2.0"); // app id + auth code
425.   out.write(3); // sub-block size
426.   out.write(1); // loop sub-block id
427.   writeShort(repeat); // loop count (extra iterations, 0=repeat forever)
428.   out.write(0); // block terminator
429.  }
431.  /**
432.   * Writes color table
433.   */
434.  protected void writePalette() throws IOException {
435.   out.write(colorTab, 0, colorTab.length);
436.   int n = (3 * 256) - colorTab.length;
437.   for (int i = 0; i < n; i++) {
438.    out.write(0);
439.   }
440.  }
442.  /**
443.   * Encodes and writes pixel data
444.   */
445.  protected void writePixels() throws IOException {
446.   LZWEncoder encoder =
447.    new LZWEncoder(width, height, indexedPixels, colorDepth);
448.   encoder.encode(out);
449.  }
451.  /**
452.   *    Write 16-bit value to output stream, LSB first
453.   */
454.  protected void writeShort(int value) throws IOException {
455.   out.write(value & 0xff);
456.   out.write((value >> 8) & 0xff);
457.  }
459.  /**
460.   * Writes string to output stream
461.   */
462.  protected void writeString(String s) throws IOException {
463.   for (int i = 0; i < s.length(); i++) {
464.    out.write((byte) s.charAt(i));
465.   }
466.  }
467. }

 

 

LZWEncoder.java

 

1. import java.io.OutputStream;
2. import java.io.IOException;
4. //==============================================================================
5. //  Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
6. //  K Weiner 12/00
8. class LZWEncoder {
10.  private static final int EOF = -1;
12.  private int imgW, imgH;
13.  private byte[] pixAry;
14.  private int initCodeSize;
15.  private int remaining;
16.  private int curPixel;
18.  // GIFCOMPR.C       - GIF Image compression routines
19.  //
20.  // Lempel-Ziv compression based on 'compress'.  GIF modifications by
21.  // David Rowley ([e-mail])
23.  // General DEFINEs
25.  static final int BITS = 12;
27.  static final int HSIZE = 5003; // 80% occupancy
29.  // GIF Image compression - modified 'compress'
30.  //
31.  // Based on: compress.c - File compression ala IEEE Computer, June 1984.
32.  //
33.  // By Authors:  Spencer W. Thomas      (decvax!harpo!utah-cs!utah-gr!thomas)
34.  //              Jim McKie              (decvax!mcvax!jim)
35.  //              Steve Davies           (decvax!vax135!petsd!peora!srd)
36.  //              Ken Turkowski          (decvax!decwrl!turtlevax!ken)
37.  //              James A. Woods         (decvax!ihnp4!ames!jaw)
38.  //              Joe Orost              (decvax!vax135!petsd!joe)
40.  int n_bits; // number of bits/code
41.  int maxbits = BITS; // user settable max # bits/code
42.  int maxcode; // maximum code, given n_bits
43.  int maxmaxcode = 1 << BITS; // should NEVER generate this code
45.  int[] htab = new int[HSIZE];
46.  int[] codetab = new int[HSIZE];
48.  int hsize = HSIZE; // for dynamic table sizing
50.  int free_ent = 0; // first unused entry
52.  // block compression parameters -- after all codes are used up,
53.  // and compression rate changes, start over.
54.  boolean clear_flg = false;
56.  // Algorithm:  use open addressing double hashing (no chaining) on the
57.  // prefix code / next character combination.  We do a variant of Knuth's
58.  // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
59.  // secondary probe.  Here, the modular division first probe is gives way
60.  // to a faster exclusive-or manipulation.  Also do block compression with
61.  // an adaptive reset, whereby the code table is cleared when the compression
62.  // ratio decreases, but after the table fills.  The variable-length output
63.  // codes are re-sized at this point, and a special CLEAR code is generated
64.  // for the decompressor.  Late addition:  construct the table according to
65.  // file size for noticeable speed improvement on small files.  Please direct
66.  // questions about this implementation to ames!jaw.
68.  int g_init_bits;
70.  int ClearCode;
71.  int EOFCode;
73.  // output
74.  //
75.  // Output the given code.
76.  // Inputs:
77.  //      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
78.  //              that n_bits =< wordsize - 1.
79.  // Outputs:
80.  //      Outputs code to the file.
81.  // Assumptions:
82.  //      Chars are 8 bits long.
83.  // Algorithm:
84.  //      Maintain a BITS character long buffer (so that 8 codes will
85.  // fit in it exactly).  Use the VAX insv instruction to insert each
86.  // code in turn.  When the buffer fills up empty it and start over.
88.  int cur_accum = 0;
89.  int cur_bits = 0;
91.  int masks[] =
92.   {
93.    0x0000,
94.    0x0001,
95.    0x0003,
96.    0x0007,
97.    0x000F,
98.    0x001F,
99.    0x003F,
100.    0x007F,
101.    0x00FF,
102.    0x01FF,
103.    0x03FF,
104.    0x07FF,
105.    0x0FFF,
106.    0x1FFF,
107.    0x3FFF,
108.    0x7FFF,
109.    0xFFFF };
111.  // Number of characters so far in this 'packet'
112.  int a_count;
114.  // Define the storage for the packet accumulator
115.  byte[] accum = new byte[256];
117.  //----------------------------------------------------------------------------
118.  LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
119.   imgW = width;
120.   imgH = height;
121.   pixAry = pixels;
122.   initCodeSize = Math.max(2, color_depth);
123.  }
125.  // Add a character to the end of the current packet, and if it is 254
126.  // characters, flush the packet to disk.
127.  void char_out(byte c, OutputStream outs) throws IOException {
128.   accum[a_count++] = c;
129.   if (a_count >= 254)
130.    flush_char(outs);
131.  }
133.  // Clear out the hash table
135.  // table clear for block compress
136.  void cl_block(OutputStream outs) throws IOException {
137.   cl_hash(hsize);
138.   free_ent = ClearCode + 2;
139.   clear_flg = true;
141.   output(ClearCode, outs);
142.  }
144.  // reset code table
145.  void cl_hash(int hsize) {
146.   for (int i = 0; i < hsize; ++i)
147.    htab[i] = -1;
148.  }
150.  void compress(int init_bits, OutputStream outs) throws IOException {
151.   int fcode;
152.   int i /* = 0 */;
153.   int c;
154.   int ent;
155.   int disp;
156.   int hsize_reg;
157.   int hshift;
159.   // Set up the globals:  g_init_bits - initial number of bits
160.   g_init_bits = init_bits;
162.   // Set up the necessary values
163.   clear_flg = false;
164.   n_bits = g_init_bits;
165.   maxcode = MAXCODE(n_bits);
167.   ClearCode = 1 << (init_bits - 1);
168.   EOFCode = ClearCode + 1;
169.   free_ent = ClearCode + 2;
171.   a_count = 0; // clear packet
173.   ent = nextPixel();
175.   hshift = 0;
176.   for (fcode = hsize; fcode < 65536; fcode *= 2)
177.    ++hshift;
178.   hshift = 8 - hshift; // set hash code range bound
180.   hsize_reg = hsize;
181.   cl_hash(hsize_reg); // clear hash table
183.   output(ClearCode, outs);
185.   outer_loop : while ((c = nextPixel()) != EOF) {
186.    fcode = (c << maxbits) + ent;
187.    i = (c << hshift) ^ ent; // xor hashing
189.    if (htab[i] == fcode) {
190.     ent = codetab[i];
191.     continue;
192.    } else if (htab[i] >= 0) // non-empty slot
193.     {
194.     disp = hsize_reg - i; // secondary hash (after G. Knott)
195.     if (i == 0)
196.      disp = 1;
197.     do {
198.      if ((i -= disp) < 0)
199.       i += hsize_reg;
201.      if (htab[i] == fcode) {
202.       ent = codetab[i];
203.       continue outer_loop;
204.      }
205.     } while (htab[i] >= 0);
206.    }
207.    output(ent, outs);
208.    ent = c;
209.    if (free_ent < maxmaxcode) {
210.     codetab[i] = free_ent++; // code -> hashtable
211.     htab[i] = fcode;
212.    } else
213.     cl_block(outs);
214.   }
215.   // Put out the final code.
216.   output(ent, outs);
217.   output(EOFCode, outs);
218.  }
220.  //----------------------------------------------------------------------------
221.  void encode(OutputStream os) throws IOException {
222.   os.write(initCodeSize); // write "initial code size" byte
224.   remaining = imgW * imgH; // reset navigation variables
225.   curPixel = 0;
227.   compress(initCodeSize + 1, os); // compress and write the pixel data
229.   os.write(0); // write block terminator
230.  }
232.  // Flush the packet to disk, and reset the accumulator
233.  void flush_char(OutputStream outs) throws IOException {
234.   if (a_count > 0) {
235.    outs.write(a_count);
236.    outs.write(accum, 0, a_count);
237.    a_count = 0;
238.   }
239.  }
241.  final int MAXCODE(int n_bits) {
242.   return (1 << n_bits) - 1;
243.  }
245.  //----------------------------------------------------------------------------
246.  // Return the next pixel from the image
247.  //----------------------------------------------------------------------------
248.  private int nextPixel() {
249.   if (remaining == 0)
250.    return EOF;
252.   --remaining;
254.   byte pix = pixAry[curPixel++];
256.   return pix & 0xff;
257.  }
259.  void output(int code, OutputStream outs) throws IOException {
260.   cur_accum &= masks[cur_bits];
262.   if (cur_bits > 0)
263.    cur_accum |= (code << cur_bits);
264.   else
265.    cur_accum = code;
267.   cur_bits += n_bits;
269.   while (cur_bits >= 8) {
270.    char_out((byte) (cur_accum & 0xff), outs);
271.    cur_accum >>= 8;
272.    cur_bits -= 8;
273.   }
275.   // If the next entry is going to be too big for the code size,
276.   // then increase it, if possible.
277.   if (free_ent > maxcode || clear_flg) {
278.    if (clear_flg) {
279.     maxcode = MAXCODE(n_bits = g_init_bits);
280.     clear_flg = false;
281.    } else {
282.     ++n_bits;
283.     if (n_bits == maxbits)
284.      maxcode = maxmaxcode;
285.     else
286.      maxcode = MAXCODE(n_bits);
287.    }
288.   }
290.   if (code == EOFCode) {
291.    // At EOF, write the rest of the buffer.
292.    while (cur_bits > 0) {
293.     char_out((byte) (cur_accum & 0xff), outs);
294.     cur_accum >>= 8;
295.     cur_bits -= 8;
296.    }
298.    flush_char(outs);
299.   }
300.  }
301. }

 

NeuQuant.java

1. /* NeuQuant Neural-Net Quantization Algorithm
2.  * ------------------------------------------
3.  *
4.  * Copyright (c) 1994 Anthony Dekker
5.  *
6.  * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994.
7.  * See "Kohonen neural networks for optimal colour quantization"
8.  * in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367.
9.  * for a discussion of the algorithm.
10.  *
11.  * Any party obtaining a copy of these files from the author, directly or
12.  * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
13.  * world-wide, paid up, royalty-free, nonexclusive right and license to deal
14.  * in this software and documentation files (the "Software"), including without
15.  * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
16.  * and/or sell copies of the Software, and to permit persons who receive
17.  * copies from any such party to do so, with the only requirement being
18.  * that this copyright notice remain intact.
19.  */
21. // Ported to Java 12/00 K Weiner
23. public class NeuQuant {
25.  protected static final int netsize = 256; /* number of colours used */
27.  /* four primes near 500 - assume no image has a length so large */
28.  /* that it is divisible by all four primes */
29.  protected static final int prime1 = 499;
30.  protected static final int prime2 = 491;
31.  protected static final int prime3 = 487;
32.  protected static final int prime4 = 503;
34.  protected static final int minpicturebytes = (3 * prime4);
35.  /* minimum size for input image */
37.  /* Program Skeleton
38.     ----------------
39.     [select samplefac in range 1..30]
40.     [read image from input file]
41.     pic = (unsigned char*) malloc(3*width*height);
42.     initnet(pic,3*width*height,samplefac);
43.     learn();
44.     unbiasnet();
45.     [write output image header, using writecolourmap(f)]
46.     inxbuild();
47.     write output image using inxsearch(b,g,r)      */
49.  /* Network Definitions
50.     ------------------- */
52.  protected static final int maxnetpos = (netsize - 1);
53.  protected static final int netbiasshift = 4; /* bias for colour values */
54.  protected static final int ncycles = 100; /* no. of learning cycles */
56.  /* defs for freq and bias */
57.  protected static final int intbiasshift = 16; /* bias for fractions */
58.  protected static final int intbias = (((int) 1) << intbiasshift);
59.  protected static final int gammashift = 10; /* gamma = 1024 */
60.  protected static final int gamma = (((int) 1) << gammashift);
61.  protected static final int betashift = 10;
62.  protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
63.  protected static final int betagamma =
64.   (intbias << (gammashift - betashift));
66.  /* defs for decreasing radius factor */
67.  protected static final int initrad = (netsize >> 3); /* for 256 cols, radius starts */
68.  protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
69.  protected static final int radiusbias = (((int) 1) << radiusbiasshift);
70.  protected static final int initradius = (initrad * radiusbias); /* and decreases by a */
71.  protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
73.  /* defs for decreasing alpha factor */
74.  protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
75.  protected static final int initalpha = (((int) 1) << alphabiasshift);
77.  protected int alphadec; /* biased by 10 bits */
79.  /* radbias and alpharadbias used for radpower calculation */
80.  protected static final int radbiasshift = 8;
81.  protected static final int radbias = (((int) 1) << radbiasshift);
82.  protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
83.  protected static final int alpharadbias = (((int) 1) << alpharadbshift);
85.  /* Types and Global Variables
86.  -------------------------- */
88.  protected byte[] thepicture; /* the input image itself */
89.  protected int lengthcount; /* lengthcount = H*W*3 */
91.  protected int samplefac; /* sampling factor 1..30 */
93.  //   typedef int pixel[4];                /* BGRc */
94.  protected int[][] network; /* the network itself - [netsize][4] */
96.  protected int[] netindex = new int[256];
97.  /* for network lookup - really 256 */
99.  protected int[] bias = new int[netsize];
100.  /* bias and freq arrays for learning */
101.  protected int[] freq = new int[netsize];
102.  protected int[] radpower = new int[initrad];
103.  /* radpower for precomputation */
105.  /* Initialise network in range (0,0,0) to (255,255,255) and set parameters
106.     ----------------------------------------------------------------------- */
107.  public NeuQuant(byte[] thepic, int len, int sample) {
109.   int i;
110.   int[] p;
112.   thepicture = thepic;
113.   lengthcount = len;
114.   samplefac = sample;
116.   network = new int[netsize][];
117.   for (i = 0; i < netsize; i++) {
118.    network[i] = new int[4];
119.    p = network[i];
120.    p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
121.    freq[i] = intbias / netsize; /* 1/netsize */
122.    bias[i] = 0;
123.   }
124.  }
126.  public byte[] colorMap() {
127.   byte[] map = new byte[3 * netsize];
128.   int[] index = new int[netsize];
129.   for (int i = 0; i < netsize; i++)
130.    index[network[i][3]] = i;
131.   int k = 0;
132.   for (int i = 0; i < netsize; i++) {
133.    int j = index[i];
134.    map[k++] = (byte) (network[j][0]);
135.    map[k++] = (byte) (network[j][1]);
136.    map[k++] = (byte) (network[j][2]);
137.   }
138.   return map;
139.  }
141.  /* Insertion sort of network and building of netindex[0..255] (to do after unbias)
142.     ------------------------------------------------------------------------------- */
143.  public void inxbuild() {
145.   int i, j, smallpos, smallval;
146.   int[] p;
147.   int[] q;
148.   int previouscol, startpos;
150.   previouscol = 0;
151.   startpos = 0;
152.   for (i = 0; i < netsize; i++) {
153.    p = network[i];
154.    smallpos = i;
155.    smallval = p[1]; /* index on g */
156.    /* find smallest in i..netsize-1 */
157.    for (j = i + 1; j < netsize; j++) {
158.     q = network[j];
159.     if (q[1] < smallval) { /* index on g */
160.      smallpos = j;
161.      smallval = q[1]; /* index on g */
162.     }
163.    }
164.    q = network[smallpos];
165.    /* swap p (i) and q (smallpos) entries */
166.    if (i != smallpos) {
167.     j = q[0];
168.     q[0] = p[0];
169.     p[0] = j;
170.     j = q[1];
171.     q[1] = p[1];
172.     p[1] = j;
173.     j = q[2];
174.     q[2] = p[2];
175.     p[2] = j;
176.     j = q[3];
177.     q[3] = p[3];
178.     p[3] = j;
179.    }
180.    /* smallval entry is now in position i */
181.    if (smallval != previouscol) {
182.     netindex[previouscol] = (startpos + i) >> 1;
183.     for (j = previouscol + 1; j < smallval; j++)
184.      netindex[j] = i;
185.     previouscol = smallval;
186.     startpos = i;
187.    }
188.   }
189.   netindex[previouscol] = (startpos + maxnetpos) >> 1;
190.   for (j = previouscol + 1; j < 256; j++)
191.    netindex[j] = maxnetpos; /* really 256 */
192.  }
194.  /* Main Learning Loop
195.     ------------------ */
196.  public void learn() {
198.   int i, j, b, g, r;
199.   int radius, rad, alpha, step, delta, samplepixels;
200.   byte[] p;
201.   int pix, lim;
203.   if (lengthcount < minpicturebytes)
204.    samplefac = 1;
205.   alphadec = 30 + ((samplefac - 1) / 3);
206.   p = thepicture;
207.   pix = 0;
208.   lim = lengthcount;
209.   samplepixels = lengthcount / (3 * samplefac);
210.   delta = samplepixels / ncycles;
211.   alpha = initalpha;
212.   radius = initradius;
214.   rad = radius >> radiusbiasshift;
215.   if (rad <= 1)
216.    rad = 0;
217.   for (i = 0; i < rad; i++)
218.    radpower[i] =
219.     alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
221.   //fprintf(stderr,"beginning 1D learning: initial radius=%d/n", rad);
223.   if (lengthcount < minpicturebytes)
224.    step = 3;
225.   else if ((lengthcount % prime1) != 0)
226.    step = 3 * prime1;
227.   else {
228.    if ((lengthcount % prime2) != 0)
229.     step = 3 * prime2;
230.    else {
231.     if ((lengthcount % prime3) != 0)
232.      step = 3 * prime3;
233.     else
234.      step = 3 * prime4;
235.    }
236.   }
238.   i = 0;
239.   while (i < samplepixels) {
240.    b = (p[pix + 0] & 0xff) << netbiasshift;
241.    g = (p[pix + 1] & 0xff) << netbiasshift;
242.    r = (p[pix + 2] & 0xff) << netbiasshift;
243.    j = contest(b, g, r);
245.    altersingle(alpha, j, b, g, r);
246.    if (rad != 0)
247.     alterneigh(rad, j, b, g, r); /* alter neighbours */
249.    pix += step;
250.    if (pix >= lim)
251.     pix -= lengthcount;
253.    i++;
254.    if (delta == 0)
255.     delta = 1;
256.    if (i % delta == 0) {
257.     alpha -= alpha / alphadec;
258.     radius -= radius / radiusdec;
259.     rad = radius >> radiusbiasshift;
260.     if (rad <= 1)
261.      rad = 0;
262.     for (j = 0; j < rad; j++)
263.      radpower[j] =
264.       alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
265.    }
266.   }
267.   //fprintf(stderr,"finished 1D learning: final alpha=%f !/n",((float)alpha)/initalpha);
268.  }
270.  /* Search for BGR values 0..255 (after net is unbiased) and return colour index
271.     ---------------------------------------------------------------------------- */
272.  public int map(int b, int g, int r) {
274.   int i, j, dist, a, bestd;
275.   int[] p;
276.   int best;
278.   bestd = 1000; /* biggest possible dist is 256*3 */
279.   best = -1;
280.   i = netindex[g]; /* index on g */
281.   j = i - 1; /* start at netindex[g] and work outwards */
283.   while ((i < netsize) || (j >= 0)) {
284.    if (i < netsize) {
285.     p = network[i];
286.     dist = p[1] - g; /* inx key */
287.     if (dist >= bestd)
288.      i = netsize; /* stop iter */
289.     else {
290.      i++;
291.      if (dist < 0)
292.       dist = -dist;
293.      a = p[0] - b;
294.      if (a < 0)
295.       a = -a;
296.      dist += a;
297.      if (dist < bestd) {
298.       a = p[2] - r;
299.       if (a < 0)
300.        a = -a;
301.       dist += a;
302.       if (dist < bestd) {
303.        bestd = dist;
304.        best = p[3];
305.       }
306.      }
307.     }
308.    }
309.    if (j >= 0) {
310.     p = network[j];
311.     dist = g - p[1]; /* inx key - reverse dif */
312.     if (dist >= bestd)
313.      j = -1; /* stop iter */
314.     else {
315.      j--;
316.      if (dist < 0)
317.       dist = -dist;
318.      a = p[0] - b;
319.      if (a < 0)
320.       a = -a;
321.      dist += a;
322.      if (dist < bestd) {
323.       a = p[2] - r;
324.       if (a < 0)
325.        a = -a;
326.       dist += a;
327.       if (dist < bestd) {
328.        bestd = dist;
329.        best = p[3];
330.       }
331.      }
332.     }
333.    }
334.   }
335.   return (best);
336.  }
337.  public byte[] process() {
338.   learn();
339.   unbiasnet();
340.   inxbuild();
341.   return colorMap();
342.  }
344.  /* Unbias network to give byte values 0..255 and record position i to prepare for sort
345.     ----------------------------------------------------------------------------------- */
346.  public void unbiasnet() {
348.   int i, j;
350.   for (i = 0; i < netsize; i++) {
351.    network[i][0] >>= netbiasshift;
352.    network[i][1] >>= netbiasshift;
353.    network[i][2] >>= netbiasshift;
354.    network[i][3] = i; /* record colour no */
355.   }
356.  }
358.  /* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
359.     --------------------------------------------------------------------------------- */
360.  protected void alterneigh(int rad, int i, int b, int g, int r) {
362.   int j, k, lo, hi, a, m;
363.   int[] p;
365.   lo = i - rad;
366.   if (lo < -1)
367.    lo = -1;
368.   hi = i + rad;
369.   if (hi > netsize)
370.    hi = netsize;
372.   j = i + 1;
373.   k = i - 1;
374.   m = 1;
375.   while ((j < hi) || (k > lo)) {
376.    a = radpower[m++];
377.    if (j < hi) {
378.     p = network[j++];
379.     try {
380.      p[0] -= (a * (p[0] - b)) / alpharadbias;
381.      p[1] -= (a * (p[1] - g)) / alpharadbias;
382.      p[2] -= (a * (p[2] - r)) / alpharadbias;
383.     } catch (Exception e) {
384.     } // prevents 1.3 miscompilation
385.    }
386.    if (k > lo) {
387.     p = network[k--];
388.     try {
389.      p[0] -= (a * (p[0] - b)) / alpharadbias;
390.      p[1] -= (a * (p[1] - g)) / alpharadbias;
391.      p[2] -= (a * (p[2] - r)) / alpharadbias;
392.     } catch (Exception e) {
393.     }
394.    }
395.   }
396.  }
398.  /* Move neuron i towards biased (b,g,r) by factor alpha
399.     ---------------------------------------------------- */
400.  protected void altersingle(int alpha, int i, int b, int g, int r) {
402.   /* alter hit neuron */
403.   int[] n = network[i];
404.   n[0] -= (alpha * (n[0] - b)) / initalpha;
405.   n[1] -= (alpha * (n[1] - g)) / initalpha;
406.   n[2] -= (alpha * (n[2] - r)) / initalpha;
407.  }
409.  /* Search for biased BGR values
410.     ---------------------------- */
411.  protected int contest(int b, int g, int r) {
413.   /* finds closest neuron (min dist) and updates freq */
414.   /* finds best neuron (min dist-bias) and returns position */
415.   /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
416.   /* bias[i] = gamma*((1/netsize)-freq[i]) */
418.   int i, dist, a, biasdist, betafreq;
419.   int bestpos, bestbiaspos, bestd, bestbiasd;
420.   int[] n;
422.   bestd = ~(((int) 1) << 31);
423.   bestbiasd = bestd;
424.   bestpos = -1;
425.   bestbiaspos = bestpos;
427.   for (i = 0; i < netsize; i++) {
428.    n = network[i];
429.    dist = n[0] - b;
430.    if (dist < 0)
431.     dist = -dist;
432.    a = n[1] - g;
433.    if (a < 0)
434.     a = -a;
435.    dist += a;
436.    a = n[2] - r;
437.    if (a < 0)
438.     a = -a;
439.    dist += a;
440.    if (dist < bestd) {
441.     bestd = dist;
442.     bestpos = i;
443.    }
444.    biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
445.    if (biasdist < bestbiasd) {
446.     bestbiasd = biasdist;
447.     bestbiaspos = i;
448.    }
449.    betafreq = (freq[i] >> betashift);
450.    freq[i] -= betafreq;
451.    bias[i] += (betafreq << gammashift);
452.   }
453.   freq[bestpos] += beta;
454.   bias[bestpos] -= betagamma;
455.   return (bestbiaspos);
456.  }
457. }

 

本想上传附件上来,但是初用,所以还不会……@#$#!@#

将就看一下吧