Java图形程序水纹倒映效果

本文涉及的产品
文档翻译,文档翻译 1千页
语种识别,语种识别 100万字符
文本翻译,文本翻译 100万字符
简介:
效果图如下:


package  org.test;

import  java.awt.Color;
import  java.awt.Frame;
import  java.awt.Graphics;
import  java.awt.Image;
import  java.awt.MediaTracker;
import  java.awt.Panel;
import  java.awt.image.BufferedImage;
import  java.awt.image.MemoryImageSource;
import  java.awt.image.PixelGrabber;

import  org.loon.framework.game.helper.ImageHelper;

/**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:Java图形程序水纹倒映效果
 * </p>
 * <p>
 * Copyright: Copyright (c) 2007
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * 
 * 
@author chenpeng
 * @email:[email]ceponline@yahoo.com.cn[/email]
 * 
@version 0.1
 
*/

public   class  ImageWave  extends  Panel  implements  Runnable  {

    
/**
     * 
     
*/

    
private static final long serialVersionUID = 1L;

    
private Thread thread;

    
private Image _image;

    
private MediaTracker _mt;

    
private int _delay;

    
private Graphics _bg;

    
private Image _screen;

    
private boolean _playing;

    
private int _pixels[];

    
private int _mpixels[];

    
private int _wpixels[];

    
private final static int _WIDTH = 480;

    
private final static int _HEIGHT = 604;

    
private Image _images[];

    
private int _sleep;

    
private int _frame;

    
/**
     * 构造函数,注入背景图与延迟时间
     * 
     * 
@param img
     * 
@param delay
     
*/

    
public ImageWave(Image img, int delay) {
        _delay 
= delay;

        init(img, delay);

    }


    
public void init(Image img, int delay) {
        setBackground(Color.BLACK);
        _image 
= img;
        _mt 
= new MediaTracker(this);
        _mt.addImage(_image, 
0);
        _mt.checkAll(
true);
        _frame 
= 10;
        _screen 
= new BufferedImage(_WIDTH, _HEIGHT, 1);
        _bg 
= _screen.getGraphics();
        thread 
= new Thread(this);
        thread.start();
    }


    
public void run() {
        Thread.currentThread().setPriority(
1);
        
long l = System.currentTimeMillis();
        
while (Thread.currentThread() == thread)
            
try {
                repaint();
                _sleep
++;
                l 
+= _delay;
                Thread.sleep(Math.max(
0L, l - System.currentTimeMillis()));
            }
 catch (InterruptedException _ex) {
                
return;
            }

    }


    
/**
     * 绘制图象
     
*/

    
public void paint(Graphics g) {

        
if (!_playing) {
            
if (_mt.checkAll()) {
                _playing 
= true;
                _bg.drawImage(_image, 
00this);
                _pixels 
= new int[(_WIDTH * _HEIGHT) / 2];
                _mpixels 
= new int[(_WIDTH * _HEIGHT) / 2];
                _wpixels 
= new int[((_WIDTH * _HEIGHT) / 2* _frame];
                PixelGrabber pixelgrabber 
= new PixelGrabber(_image, 00,
                        _WIDTH, _HEIGHT 
/ 2, _pixels, 0, _WIDTH);
                
try {
                    pixelgrabber.grabPixels();
                }
 catch (InterruptedException _ex) {
                }

                blure();
                _images 
= new Image[_frame];
                
for (int i = 0; i < _frame; i++)
                    _images[i] 
= createMirrorImage(i);

            }

        }
 else {
            
if (_sleep > _frame - 1)
                _sleep 
= 0;
            _bg.drawImage(_images[_sleep], 
0, _HEIGHT / 2this);
        }

        g.drawImage(_screen, 
00this);
    }


    
public void update(Graphics g) {
        paint(g);
    }


    
/**
     * 创建波纹反射图片
     * 
     * 
@param i
     * 
@return
     
*/

    Image createMirrorImage(
int i) {
        
int k1 = _HEIGHT / 2;
        
int j1 = i * _WIDTH * k1;
        
for (int k = 0; k < k1; k++{
            
int l = k * _WIDTH;
            
int i1 = k1 - k - 1;
            i1 
+= (int) ((double) ((k * 5/ k1 + 2* Math
                    .sin((
25.132741228718345D * (double) i1 * (double) i1)
                            
/ (double) k1 / (double) k1
                            
- (6.2831853071795862D * (double) i)
                            
/ (double) _frame));
            
if (i1 < 0)
                i1 
= 0;
            
if (i1 > k1 - 1)
                i1 
= k1 - 1;
            i1 
*= _WIDTH;
            
for (int j = 0; j < _WIDTH; j++)
                _wpixels[j1 
+ j + l] = _mpixels[j + i1];

        }


        Image image 
= createImage(new MemoryImageSource(_WIDTH, k1, _wpixels,
                j1, _WIDTH));
        
return image;
    }


    
/**
     * 模糊化反射图片
     * 
     
*/

    
void blure() {
        
int l = _HEIGHT / 2;
        
for (int j = 0; j < l; j++{
            
int k = j * _WIDTH;
            
for (int i = 0; i < _WIDTH; i++{
                
int i1 = _pixels[i + k];
                
int j1;
                
if (i != _WIDTH - 1)
                    j1 
= _pixels[i + k + 1];
                
else
                    j1 
= _pixels[(i + k) - 1];
                
int k1 = 0;
                
if (j != l - 1)
                    k1 
= _pixels[i + k + _WIDTH];
                
else
                    k1 
= _pixels[(i + k) - _WIDTH];
                
int l1 = 0;
                
if (j != l - 1 && i != _WIDTH - 1)
                    l1 
= _pixels[i + k + _WIDTH + 1];
                
else
                    l1 
= _pixels[i + k];
                
int i2 = (i1 >> 16 & 0xff+ (j1 >> 16 & 0xff)
                        
+ (k1 >> 16 & 0xff+ (l1 >> 16 & 0xff);
                
int j2 = (i1 >> 8 & 0xff+ (j1 >> 8 & 0xff+ (k1 >> 8 & 0xff)
                        
+ (l1 >> 8 & 0xff);
                
int k2 = (i1 & 0xff+ (j1 & 0xff+ (k1 & 0xff+ (l1 & 0xff);
                i2 
>>= 3;
                j2 
= (j2 >> 3+ (j2 >> 4);
                k2 
= (k2 >> 3+ (k2 >> 4);
                _mpixels[i 
+ k] = i1 & 0xff000000 | i2 << 16 | j2 << 8 | k2;
            }


        }


    }


    
public static void main(String[] args) {
        Frame frm 
= new Frame();
        frm.setTitle(
"Java图形程序水纹倒映效果(由Loonframework提供)");
        frm.setSize(_WIDTH, _HEIGHT 
+ 20);
        frm.setResizable(
false);
        frm.add(
new ImageWave(ImageHelper.loadImage("C:/back.jpg"true), 100));
        frm.setVisible(
true);
    }


}


本文转自 cping 51CTO博客,原文链接:http://blog.51cto.com/cping1982/130192
相关文章
|
8天前
|
缓存 监控 安全
如何提高 Java 高并发程序的性能?
以下是提升Java高并发程序性能的方法:优化线程池设置,减少锁竞争,使用读写锁和无锁数据结构。利用缓存减少重复计算和数据库查询,并优化数据库操作,采用连接池和分库分表策略。应用异步处理,选择合适的数据结构如`ConcurrentHashMap`。复用对象和资源,使用工具监控性能并定期审查代码,遵循良好编程规范。
|
20天前
|
Java 编译器 开发者
Java中的异常处理是确保程序稳定性的关键
Java中的异常处理是确保程序稳定性的关键。本文探讨八大最佳实践:理解异常体系,选用恰当异常类型,提供详细错误信息,精用try-catch,善用finally块,利用try-with-resources简化资源管理,记录异常便于追踪,及避免finally中抛异常。遵循这些原则,提升代码质量和错误管理能力。
12 1
|
23天前
|
Java 开发者
在Java编程的广阔天地中,if-else与switch语句犹如两位老练的舵手,引领着代码的流向,决定着程序的走向。
在Java编程中,if-else与switch语句是条件判断的两大利器。本文通过丰富的示例,深入浅出地解析两者的特点与应用场景。if-else适用于逻辑复杂的判断,而switch则在处理固定选项或多分支选择时更为高效。从逻辑复杂度、可读性到性能考量,我们将帮助你掌握何时选用哪种语句,让你在编程时更加得心应手。无论面对何种挑战,都能找到最适合的解决方案。
24 1
|
23天前
|
搜索推荐 Java 程序员
在Java编程的旅程中,条件语句是每位开发者不可或缺的伙伴,它如同导航系统,引导着程序根据不同的情况做出响应。
在Java编程中,条件语句是引导程序根据不同情境作出响应的核心工具。本文通过四个案例深入浅出地介绍了如何巧妙运用if-else与switch语句。从基础的用户登录验证到利用switch处理枚举类型,再到条件语句的嵌套与组合,最后探讨了代码的优化与重构。每个案例都旨在帮助开发者提升编码效率与代码质量,无论是初学者还是资深程序员,都能从中获得灵感,让自己的Java代码更加优雅和专业。
11 1
|
23天前
|
Java
在Java编程的广阔天地中,条件语句是控制程序流程、实现逻辑判断的重要工具。
在Java编程中,if-else与switch作为核心条件语句,各具特色。if-else以其高度灵活性,适用于复杂逻辑判断,支持多种条件组合;而switch在多分支选择上表现优异,尤其适合处理枚举类型或固定选项集,通过内部跳转表提高执行效率。两者各有千秋:if-else擅长复杂逻辑,switch则在多分支选择中更胜一筹。理解它们的特点并在合适场景下使用,能够编写出更高效、易读的Java代码。
22 1
|
17天前
|
数据采集 人工智能 监控
【Azure 应用程序见解】Application Insights Java Agent 3.1.0的使用实验,通过修改单个URL的采样率来减少请求及依赖项的数据采集
【Azure 应用程序见解】Application Insights Java Agent 3.1.0的使用实验,通过修改单个URL的采样率来减少请求及依赖项的数据采集
|
18天前
|
Java jenkins Shell
还有人不会启动JAVA程序
还有人不会启动JAVA程序
11 0
|
19天前
|
Java 调度
|
19天前
|
监控 Java API
如何从 Java 程序中查找内存使用情况
【8月更文挑战第22天】
13 0
|
19天前
|
Java
下一篇
DDNS