[Java] Java 实现图片水纹倒映效果 →→→→→进入此内容的聊天室

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

回复 "Java 实现图片水纹倒映效果"

这儿你可以回复上面这条便签

captcha