在CSDN中下了了个烟火的程序，好好看了并分析了下，十再是太好玩了，太精彩了。想着想着有了一个问题，查API无果，特来此问下。问题如下：
public class MemoryImageSource extends Object implements ImageProducer
这个类大伙有应该用过的吧。用途：uses an array to produce pixel values for an Image.
我在想，可不可将一个jpeg（或者bmp等等）类型的图片读取到内存中，然后读取这个图片的实实在在的像素值（就是我们看到的图片的每个像素点的像素值），而不要那些个该格式文件的一些标准啊APPO标记啊等。
我现在正在查jpeg格式文件的描述，看下看有没有帮助不知道。
都23：00了，再看会书就睡了，上床看去关机咧。
哪位帮下，谢谢。
public class MemoryImageSource extends Object implements ImageProducer
这个类大伙有应该用过的吧。用途：uses an array to produce pixel values for an Image.
我在想，可不可将一个jpeg（或者bmp等等）类型的图片读取到内存中，然后读取这个图片的实实在在的像素值（就是我们看到的图片的每个像素点的像素值），而不要那些个该格式文件的一些标准啊APPO标记啊等。
我现在正在查jpeg格式文件的描述，看下看有没有帮助不知道。
都23：00了，再看会书就睡了，上床看去关机咧。
哪位帮下，谢谢。
...
In general, the pixel data of a RenderedImage may be obtained by calling the getPixels() method. By definition, the pixel data of an image are the data described by the image's SampleModel and stored in the image's Rasters. No consideration of any kind is given to the image's ColorModel. If no error is found, the pixel data are returned in the primitive arrays of the type specified by the caller in an unpacked format, along with access information. Therefore, the specified data type must be one of the valid types defined in DataBuffer and large enough (in bit depth) to hold the pixel data of the image.
...COPY过来的希望对你有帮助
另：谢谢2楼的先，我刚刚开电脑上线来，先发源码了，马上去查下，看行不行。
import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.*;
import java.awt.image.MemoryImageSource;
import java.util.Random;
public class TestFire extends Applet implements Runnable {
private int m_nAppX;
private int m_nAppY;
private int m_centerX;
private int m_centerY;
private int m_mouseX;
private int m_mouseY;
private int m_sleepTime;
private boolean isError;
boolean isRunning;
boolean isInitialized;
Thread runner;
int pix0[];
MemoryImageSource offImage;
Image dbImg;
int pixls;
int pixls2;
Random rand;
int bits;
double bit_px[];
double bit_py[];
double bit_vx[];
double bit_vy[];
int bit_sx[];
int bit_sy[];
int bit_l[];
int bit_f[];
int bit_p[];
int bit_c[];
int bit_max;
int bit_sound;
int ru;
int rv;
AudioClip sound1;
AudioClip sound2;
public TestFire() {
m_mouseX = 0; //鼠标点击点的坐标
m_mouseY = 0;
m_sleepTime = 5; //线程执行时间间隔
isError = false;
isInitialized = false;
rand = new Random();
bits = 10000;
bit_px = new double[bits];
bit_py = new double[bits];
bit_vx = new double[bits];
bit_vy = new double[bits];
bit_sx = new int[bits];
bit_sy = new int[bits];
bit_l = new int[bits];
bit_f = new int[bits];
bit_p = new int[bits];
bit_c = new int[bits];
ru = 50;
rv = 50;
}
public void init() {
String s = getParameter("para_bits");
if (s != null)
bits = Integer.parseInt(s);
s = getParameter("para_max");
if (s != null)
bit_max = Integer.parseInt(s);
s = getParameter("para_blendx");
if (s != null)
ru = Integer.parseInt(s);
s = getParameter("para_blendy");
if (s != null)
rv = Integer.parseInt(s);
s = getParameter("para_sound");
if (s != null)
bit_sound = Integer.parseInt(s);
m_nAppX = getSize().width;
m_nAppY = getSize().height;
m_centerX = m_nAppX / 2;
m_centerY = m_nAppY / 2;
m_mouseX = m_centerX;
m_mouseY = m_centerY;
resize(m_nAppX, m_nAppY);
pixls = m_nAppX * m_nAppY;
pixls2 = pixls - m_nAppX * 2;
pix0 = new int[pixls]; //保存图片每个像素的值的数组
offImage = new MemoryImageSource(m_nAppX, m_nAppY, pix0, 0, m_nAppX); //初始化内存图片
offImage.setAnimated(true); //设置此内存图像是一个多帧动画
dbImg = createImage(offImage); //用内存图片数据产生一个图片
for (int i = 0; i < pixls; i++)
pix0[i] = 0xff000000;
sound1 = getAudioClip(getDocumentBase(), "firework.au"); //getDocumentBase()返回当前html文件的URL值
sound2 = getAudioClip(getDocumentBase(), "syu.au");
for (int j = 0; j < bits; j++)
bit_f[j] = 0;
isInitialized = true;
start();
}
private boolean stop;
public void run() {
while (!isInitialized) //while语句段处理当init没被初始化时执行，抛出异常
try {
Thread.sleep(200L);
} catch (InterruptedException interruptedexception) {
}
//do while语句分两个扫描行开始扫描图片
//横排两个相邻像素点相互处理 竖排两个相邻像素点相互处理 的方法十再不解
//因为处理的颜色最终还是变成了黑色(可能是始终用的加法，到最后都变0了) 即R=G=B=0 方法暂且记住
do {
for (int j = 0; j < pixls2; j++) {
int k = pix0[j]; //run()方法开始运行后，把图片的第j个像素点的值给k
int l = pix0[j + 1]; //把图片的第j+1个像素点的值给l
int i1 = pix0[j + m_nAppX]; //把图片的第j+图片宽度个像素点的值给i1
int j1 = pix0[j + m_nAppX + 1]; //把图片的第j+图片宽度+1个像素点的值给j1
//第一行扫描
int i = (k & 0xff0000) >> 16; //把第j个像素点的R值提取出来
int k1 = ((((l & 0xff0000) >> 16) - i) * ru >> 8) + i; //第j个像素点和第j+1个像素点经过运算得到k1
i = (k & 0xff00) >> 8; //G值处理
int l1 = ((((l & 0xff00) >> 8) - i) * ru >> 8) + i;
i = k & 0xff; //B值处理
int i2 = (((l & 0xff) - i) * ru >> 8) + i;
//第二行扫描
i = (i1 & 0xff0000) >> 16;
int j2 = ((((j1 & 0xff0000) >> 16) - i) * ru >> 8) + i;
i = (i1 & 0xff00) >> 8;
int k2 = ((((j1 & 0xff00) >> 8) - i) * ru >> 8) + i;
i = i1 & 0xff;
int l2 = (((j1 & 0xff) - i) * ru >> 8) + i;
//得到最终的新像素点的值
int i3 = ((j2 - k1) * rv >> 8) + k1;
int j3 = ((k2 - l1) * rv >> 8) + l1;
int k3 = ((l2 - i2) * rv >> 8) + i2;
pix0[j] = i3 << 16 | j3 << 8 | k3 | 0xff000000;
}
//System.out.println("send");//huyu
rend();
offImage.newPixels(0, 0, m_nAppX, m_nAppY);
try {
Thread.sleep(m_sleepTime);
} catch (InterruptedException interruptedexception1) {
}
} while (!stop);
}
public void update(Graphics g) {
paint(g);
}
public void paint(Graphics g) {
g.drawImage(dbImg, 0, 0, this);
}
public void start() {
if (isError)
return;
isRunning = true;
if (runner == null) {
runner = new Thread(this);
runner.start();
}
}
public void stop() {
if (runner != null) {
runner.stop();
runner = null;
}
}
public boolean mouseMove(Event event, int i, int j) {
m_mouseX = i;
m_mouseY = j;
return true;
}
public boolean mouseDown(Event event, int i, int j) {
m_mouseX = i;
m_mouseY = j;
int k = (int) (rand.nextDouble() * 256D);
int l = (int) (rand.nextDouble() * 256D);
int i1 = (int) (rand.nextDouble() * 256D);
int j1 = k << 16 | l << 8 | i1 | 0xff000000;
int k1 = 0;
for (int l1 = 0; l1 < bits; l1++) {
if (bit_f[l1] != 0)
continue;
bit_px[l1] = m_mouseX;
bit_py[l1] = m_mouseY;
double d = rand.nextDouble() * 6.2800000000000002D; //这里的6.28000其实就是2*PAI,d的值其实是随机的一个弧度
double d1 = rand.nextDouble();
bit_vx[l1] = Math.sin(d) * d1; //vx vy保存着由上面随机弧度所产生的随机点的坐标
bit_vy[l1] = Math.cos(d) * d1;
bit_l[l1] = (int) (rand.nextDouble() * 100D) + 100; //bit_l最大值为100+100
bit_p[l1] = (int) (rand.nextDouble() * 3D); //bit_p最大值为3
bit_c[l1] = j1;
bit_sx[l1] = m_mouseX; //sx sy保存着烟火发出点的坐标
bit_sy[l1] = m_nAppY - 5;
bit_f[l1] = 2;
if (++k1 == bit_max) //只保存了150个烟火随机发散点
break;
}
if (bit_sound > 1)
sound2.play();
return true;
}
public boolean mouseExit(Event event, int i, int j) {
m_mouseX = i;
m_mouseY = j;
return true;
}
void rend() {
boolean flag2 = false;
//int q = 0;//huyu
for (int k = 0; k < bits; k++) {
//System.out.println(bit_f[k]);
switch (bit_f[k]) {
default:
break;
case 1: // '\001'
bit_vy[k] += rand.nextDouble() / 50D;
bit_px[k] += bit_vx[k];
bit_py[k] += bit_vy[k];
bit_l[k]--;
if (bit_l[k] == 0 || bit_px[k] < 0.0D || bit_py[k] < 0.0D || bit_px[k] > (double) m_nAppX
|| bit_py[k] > (double) (m_nAppY - 3)) {
bit_c[k] = 0xff000000;
bit_f[k] = 0;
} else if (bit_p[k] == 0) {
if ((int) (rand.nextDouble() * 2D) == 0)
bit_set((int) bit_px[k], (int) bit_py[k], -1);
} else {
bit_set((int) bit_px[k], (int) bit_py[k], bit_c[k]);
}
break;
case 2: // '\002'
//System.out.println("up"+(q++)); //huyu
bit_sy[k] -= 5; //bit_sy减少后，烟火上升
//System.out.println(bit_sy[k]);
if ((double) bit_sy[k] <= bit_py[k]) {
bit_f[k] = 1;
flag2 = true;
}
if ((int) (rand.nextDouble() * 20D) == 0) {
int i = (int) (rand.nextDouble() * 2D);
int j = (int) (rand.nextDouble() * 5D);
bit_set(bit_sx[k] + i, bit_sy[k] + j, -1);
}
break;
}
}
if (flag2 && bit_sound > 0)
sound1.play();
}
void bit_set(int i, int j, int k) {
int l = i + j * m_nAppX;
pix0[l] = k;
}
}
//**********HTML代码*************
<APPLET align=baseline code=Test.class height=260 width=800>
<PARAM NAME="para_bits" VALUE="10000">
<PARAM NAME="para_max" VALUE="150">
<PARAM NAME="para_blendx" VALUE="50">
<PARAM NAME="para_blendy" VALUE="50">
<PARAM NAME="para_sound" VALUE="2">
<PARAM NAME="align" VALUE="baseline">
<PARAM NAME="code" VALUE="TestFire.class">
<param name="codeBase" value=".">
<PARAM NAME="height" VALUE="250">
<PARAM NAME="width" VALUE="800">
</APPLET>
是这个类PixelGrabber（暂且译成像素抓帧器吧）
java.awt.image.PixelGrabber
public class PixelGrabber extends Object implements ImageConsumer
描述：
The PixelGrabber class implements an ImageConsumer which can be attached to an Image or ImageProducer object to retrieve a subset of the pixels in that image.
看了这个类里面的一个example，知道怎么去获取了。
大体方法：
1.用其构造方法构造一个该类的实例
PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
2.调用pg.grabberPixels()
3.pixels这里面保存了像素值的int数组pixels.length=图片的宽*图片的高。谢谢各位。