Go语言视频零基础入门到精通

javalearner

  
  
  

1. 
   
2. 程序：
   
3. import java.awt.Color;
   
4. import java.awt.Frame;
   
5. import java.awt.Graphics;
   
6. import java.awt.Image;
   
7. import java.awt.MediaTracker;
   
8. import java.awt.Panel;
   
9. import java.awt.image.BufferedImage;
   
10. import java.awt.image.MemoryImageSource;
    
11. import java.awt.image.PixelGrabber;
    
12. import javax.imageio.ImageIO;
    
13. import java.io.File;
    
14. import java.awt.Toolkit;
15. 
    
16. /** *
    
17. //**
    
18. *  * Title: LoonFramework
    
19. *
    
20. *
    
21. * Description:Java图形程序水纹倒映效果
    
22. *
    
23. *
    
24. * Copyright: Copyright (c) 2007
    
25. *
    
26. *
    
27. * Company: LoonFramework
    
28. *
    
29. *
    
30. * @author chenpeng
    
31. * @email：ceponline@yahoo.com.cn
    
32. * @version 0.1
    
33. */
    
34. public class ImageWave extends Panel implements Runnable {
    
35.     /** *//**
    
36.      *
    
37.      */
    
38.     private static final long serialVersionUID = 1L;
    
39.     private Thread thread;
    
40.     private Image _image;
    
41.     private MediaTracker _mt;
    
42.     private int _delay;
    
43.     private Graphics _bg;
    
44.     private Image _screen;
    
45.     private boolean _playing;
    
46.     private int _pixels[];
    
47.     private int _mpixels[];
    
48.     private int _wpixels[];
    
49.     private final static int _WIDTH = 300;
    
50.     private final static int _HEIGHT = 378;
    
51.     private Image _images[];
    
52.     private int _sleep;
    
53.     private int _frame;
    
54.     /** *//**
    
55.      * 构造函数,注入背景图与延迟时间
    
56.      *
    
57.      * @param img
    
58.      * @param delay
    
59.      */
    
60.     public ImageWave(Image img, int delay) {
    
61.         _delay = delay;
    
62.         init(img, delay);
    
63.     }
    
64.     public void init(Image img, int delay) {
    
65.         setBackground(Color.BLACK);
    
66.         _image = img;
    
67.         _mt = new MediaTracker(this);
    
68.         _mt.addImage(_image, 0);
    
69.         _mt.checkAll(true);
    
70.         _frame = 10;
    
71.         _screen = new BufferedImage(_WIDTH, _HEIGHT, 1);
    
72.         _bg = _screen.getGraphics();
    
73.         thread = new Thread(this);
    
74.         thread.start();
    
75.     }
    
76.     public void run() {
    
77.         Thread.currentThread().setPriority(1);
    
78.         long l = System.currentTimeMillis();
    
79.         while (Thread.currentThread() == thread)
    
80.             try {
    
81.                 repaint();
    
82.                 _sleep++;
    
83.                 l += _delay;
    
84.                 Thread.sleep(Math.max(0L, l - System.currentTimeMillis()));
    
85.             } catch (InterruptedException _ex) {
    
86.                 return;
    
87.             }
    
88.     }
    
89.     /** *//**
    
90.      * 绘制图象
    
91.      */
    
92.     public void paint(Graphics g) {
    
93.         if (!_playing) {
    
94.             if (_mt.checkAll()) {
    
95.                 _playing = true;
    
96.                 _bg.drawImage(_image, 0, 0, this);
    
97.                 _pixels = new int[(_WIDTH * _HEIGHT) / 2];
    
98.                 _mpixels = new int[(_WIDTH * _HEIGHT) / 2];
    
99.                 _wpixels = new int[((_WIDTH * _HEIGHT) / 2) * _frame];
    
100.                 PixelGrabber pixelgrabber = new PixelGrabber(_image, 0, 0,
     
101.                         _WIDTH, _HEIGHT / 2, _pixels, 0, _WIDTH);
     
102.                 try {
     
103.                     pixelgrabber.grabPixels();
     
104.                 } catch (InterruptedException _ex) {
     
105.                 }
     
106.                 blure();
     
107.                 _images = new Image[_frame];
     
108.                 for (int i = 0; i < _frame; i++)
     
109.                     _images[i] = createMirrorImage(i);
     
110.             }
     
111.         } else {
     
112.             if (_sleep > _frame - 1)
     
113.                 _sleep = 0;
     
114.             _bg.drawImage(_images[_sleep], 0, _HEIGHT / 2, this);
     
115.         }
     
116.         g.drawImage(_screen, 0, 0, this);
     
117.     }
     
118.     public void update(Graphics g) {
     
119.         paint(g);
     
120.     }
     
121.     /** *//**
     
122.      * 创建波纹反射图片
     
123.      *
     
124.      * @param i
     
125.      * @return
     
126.      */
     
127.     Image createMirrorImage(int i) {
     
128.         int k1 = _HEIGHT / 2;
     
129.         int j1 = i * _WIDTH * k1;
     
130.         for (int k = 0; k < k1; k++) {
     
131.             int l = k * _WIDTH;
     
132.             int i1 = k1 - k - 1;
     
133.             i1 += (int) ((double) ((k * 5) / k1 + 2) * Math
     
134.                     .sin((25.132741228718345D * (double) i1 * (double) i1)
     
135.                             / (double) k1 / (double) k1
     
136.                             - (6.2831853071795862D * (double) i)
     
137.                             / (double) _frame));
     
138.             if (i1 < 0)
     
139.                 i1 = 0;
     
140.             if (i1 > k1 - 1)
     
141.                 i1 = k1 - 1;
     
142.             i1 *= _WIDTH;
     
143.             for (int j = 0; j < _WIDTH; j++)
     
144.                 _wpixels[j1 + j + l] = _mpixels[j + i1];
     
145.         }
     
146.         Image image = createImage(new MemoryImageSource(_WIDTH, k1, _wpixels,
     
147.                 j1, _WIDTH));
     
148.         return image;
     
149.     }
     
150.     /** *//**
     
151.      * 模糊化反射图片
     
152.      *
     
153.      */
     
154.     void blure() {
     
155.         int l = _HEIGHT / 2;
     
156.         for (int j = 0; j < l; j++) {
     
157.             int k = j * _WIDTH;
     
158.             for (int i = 0; i < _WIDTH; i++) {
     
159.                 int i1 = _pixels[i + k];
     
160.                 int j1;
     
161.                 if (i != _WIDTH - 1)
     
162.                     j1 = _pixels[i + k + 1];
     
163.                 else
     
164.                     j1 = _pixels[(i + k) - 1];
     
165.                 int k1 = 0;
     
166.                 if (j != l - 1)
     
167.                     k1 = _pixels[i + k + _WIDTH];
     
168.                 else
     
169.                     k1 = _pixels[(i + k) - _WIDTH];
     
170.                 int l1 = 0;
     
171.                 if (j != l - 1 && i != _WIDTH - 1)
     
172.                     l1 = _pixels[i + k + _WIDTH + 1];
     
173.                 else
     
174.                     l1 = _pixels[i + k];
     
175.                 int i2 = (i1 >> 16 & 0xff) + (j1 >> 16 & 0xff)
     
176.                         + (k1 >> 16 & 0xff) + (l1 >> 16 & 0xff);
     
177.                 int j2 = (i1 >> 8 & 0xff) + (j1 >> 8 & 0xff) + (k1 >> 8 & 0xff)
     
178.                         + (l1 >> 8 & 0xff);
     
179.                 int k2 = (i1 & 0xff) + (j1 & 0xff) + (k1 & 0xff) + (l1 & 0xff);
     
180.                 i2 >>= 3;
     
181.                 j2 = (j2 >> 3) + (j2 >> 4);
     
182.                 k2 = (k2 >> 3) + (k2 >> 4);
     
183.                 _mpixels[i + k] = i1 & 0xff000000 | i2 << 16 | j2 << 8 | k2;
     
184.             }
     
185.         }
     
186.     }
     
187.     public static void main(String[] args) {
     
188.         Frame frm = new Frame();
     
189.         frm.setTitle("Java图形程序水纹倒映效果(由Loonframework提供)");
     
190.         frm.setSize(_WIDTH, _HEIGHT + 20);
     
191.         frm.setResizable(false);
     
192.         Image im=Toolkit.getDefaultToolkit().createImage("back.jpg");
     
193.         frm.add(new ImageWave(im, 100));
     
194.         frm.setVisible(true);
     
195.     }
     
196. }
     

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/11/2/235541140.zip