「像素java」像素射击下载

今天给各位分享像素java的知识，其中也会对像素射击下载进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java里像素类应该怎么建
• 2、java中如何读取图片的像素
• 3、java 怎么提取Image对象的像素数据
• 4、java中什么是像素
• 5、像素文明服务器是java
• 6、java里面获得图像像素后怎么做dct变换

java里像素类应该怎么建

//我在程序中打印出了每一个坐标的RGB值，你自己整理整理，求个平均值，

//放到你的那个二维数组里。

//自己用画图工具做一个小图片，注意图片的名字和程序中一致哦~

import java.awt.image.BufferedImage;

import javax.imageio.ImageIO;

import java.io.*;

public class Test{

public static void main(String args[]) {

int[] rgb = new int[3];

File file = new File("a.bmp");

BufferedImage bi=null;

try{

bi = ImageIO.read(file);

}catch(Exception e){

e.printStackTrace();

}

int width=bi.getWidth();

int height=bi.getHeight();

int minx=bi.getMinX();

int miny=bi.getMinY();

System.out.println("width="+width+",height="+height+".");

System.out.println("minx="+minx+",miniy="+miny+".");

for(int i=minx;iwidth;i++){

for(int j=miny;jheight;j++){

//System.out.print(bi.getRGB(jw, ih));

int pixel=bi.getRGB(i, j);

rgb[0] = (pixel 0xff0000 ) 16 ;

rgb[1] = (pixel 0xff00 ) 8 ;

rgb[2] = (pixel 0xff );

System.out.println("i="+i+",j="+j+":("+rgb[0]+","+rgb[1]+","+rgb[2]+")");

}

}

}

}

请参考，希望能帮到你。

java中如何读取图片的像素

BufferedImage img = ImageIO.read(new File(filename));

Raster ra = img.getData();

Rectangle rect = ra.getBounds();

// int nWidth = ra.getMinX();

int nImageDate[] = new int[rect.height*rect.width];

int nTemp[] = new int[400*400];

nImageDate = ra.getPixels(0,0,rect.width, rect.height,nTemp);

java 怎么提取Image对象的像素数据

这个是一段透明化处理的代码，里面有获取像素的代码存在！希望对你有所帮助！

pixels将是像素，int pixels[] = (int[]) pgr.getPixels();这里将写入到数组中了！

/**

* 使图片中的某一种颜色透明

*

* @param image

* Image

* @param RGB16

* String 十六进制的六位颜色值字符串

* @param isFiltrate

* boolean

* @return Image

*/

public static Image setTranImage(Image image, String RGB16,

boolean isFiltrate)

{

int width = image.getWidth(null);

int height = image.getHeight(null);

Image abufferedimage = new BufferedImage(width, height, 2);

Graphics g = abufferedimage.getGraphics();

g.drawImage(image, 0, 0, width, height, 0, 0, width, height, null);

g.dispose();

// 透明化处理

PixelGrabber pgr = new PixelGrabber(abufferedimage, 0, 0, -1, -1, true);

try

{

pgr.grabPixels();

}

catch (InterruptedException ex)

{

ex.getStackTrace();

}

int pixels[] = (int[]) pgr.getPixels();

if (isFiltrate RGB16.length() == 6)

{

// 循环像素

for (int i = 0; i pixels.length; i++)

{

// 去色

if (((pixels[i] 0x00ff0000) 16 == Integer.parseInt(

RGB16.substring(0, 2), 16)

(pixels[i] 0x0000ff00) 8 == Integer.parseInt(

RGB16.substring(2, 4), 16) (pixels[i] 0x000000ff) == Integer

.parseInt(RGB16.substring(4, 6), 16)))

{

// 透明化

pixels[i] = 0;

}

}

}

ImageProducer ip = new MemoryImageSource(pgr.getWidth(),

pgr.getHeight(), pixels, 0, pgr.getWidth());

return toolkit.createImage(ip);

}

java中什么是像素

显示器就是由像素组成的（也就是一个一个的发光二极管，一个称为一个像素，这是物理像素）；软件里也一样，不管是位图还是窗口，都是由一个一个带颜色的小点组成的，每一个点就是一个像素

像素文明服务器是java

是的。

其实Java的重心不在游戏开发，但同样能用于游戏当中，像《我的世界》这款像素游戏，就是Java编写的，《英雄联盟》这样的爆款游戏同样是Java，像素文明也是。

java里面获得图像像素后怎么做dct变换

private void setAlpha(ByteArrayOutputStream os) {

try {

ImageIcon imageIcon = new ImageIcon(os.toByteArray());

BufferedImage bufferedImage = new BufferedImage(imageIcon.getIconWidth(),imageIcon.getIconHeight()

, BufferedImage.TYPE_4BYTE_ABGR);

Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();

g2D.drawImage(imageIcon.getImage(), 0, 0,

imageIcon.getImageObserver());

//循环每一个像素点，改变像素点的Alpha值

int alpha = 100;

for (int j1 = bufferedImage.getMinY(); j1 bufferedImage.getHeight(); j1++) {

for (int j2 = bufferedImage.getMinX(); j2 bufferedImage.getWidth(); j2++) {

int rgb = bufferedImage.getRGB(j2, j1);

rgb = ( (alpha + 1) 24) | (rgb 0x00ffffff);

bufferedImage.setRGB(j2, j1, rgb);

}

}

g2D.drawImage(bufferedImage, 0, 0, imageIcon.getImageObserver());

//生成图片为PNG

ImageIO.write(bufferedImage, "png", new File(图片路径));

}

catch (Exception e) {

e.printStackTrace();

}

}

使用JAVA对图片进行效果变换（第二幅图覆盖第一幅图的像素并显示）

一提到JAVA，谈论最多的就是JSP/SERVLET/J2EE之类的，但对于用JAVA对图片进行效果变换，到论坛里看了看，关于这方面的话题并不多，网上关于图像效果处理的文章也并不丰富，于是在自己摸索了几天，并且参考了AnfyJava(专业级的JAVA效果生成器)后，我用轻量级控件写了一个(AnfyJava继承的是Applet，Applet是java.awt包中的，属于重量级控件，SUN现在推荐使用swing来编写图形程序，因此，我用的是JApplet)。

其实，用JAVA做图像效果和其它语言在本质上并没有什么区别，只不过在实现起来有所不同罢了，下面我就把我在项目中处理的经验与大家分享一下吧。

图像的变换，实际上就是把两幅图片的内容进行某些运算，生成新的图像，然后显示出来，最终实现从一幅图片到另一幅图片的过度效果。变换的具体过程如下：

在上面的过程中，图片A和B的尺寸最好保持一致，如果不一致的话，可能要做一些额外的处理，在此，我选用的图片A和B的尺寸是一致的。

首先，我们将其当作一个Applet来写，由于Applet的局限性，不可以直接使用File类来读取图像文件，因此，我们只能通过如下方法来获取图像文件。

URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();

URL url = urlLoader.findResource("imagea.gif");

Image image = Toolkit.getDefaultToolkit().getImage(url);

当我们获得了图像后，可以通过java.awt.image.PixelGrabber包中的PixelGrabber方法来将图像中的像素信息完全读取出来，其用法如下：

PixelGrabber(Image img, int x, int y, int w, int h, int[] pix, int off, int scansize)

其中img是要读取的图像，x/y是要读取图像中的左上角坐标，w/h分别是从x/y开始起的距离，其实x,y,w,h就是一个矩形，pix是保存像素的数组，off是读取图像时开始的位置，scansize是指扫描的宽度，一般来说和w相等。

int width = image.getWidth();

int height = image.getHeight();

int size = width * height;

int[] pixels = new int[size];

pixelgrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);

try {

pixelgrabber.grabPixels(); //读取像素入数组

}

catch (InterruptedException _ex) {}

由于像素信息是由alpha,red,green,blue组成的，其格式为

因此，我们可以将颜色分解成单独的RGB信息

int alpha = (pixel 24) 0xff;

int red = (pixel 16) 0xff;

int green = (pixel 8) 0xff;

int blue = (pixel) 0xff;

假如要实现显示图片A后，图片B由上至下展开，则可以每次将图片A中的一行像素替换为B中的相应行，然后生成新的像素信息：

图像A的像素数组 图像B的像素数组

old = pixelA; //保存图片A的像素信息

oldR = redA; //保存图片A的R信息

oldG = greenA; //保存图片A的G信息

oldB = blueA; //保存图片A的B信息

for (int i = 0; i width; i++) {//line为行数

oldR[line * width + i] = redA [line * width + i];

oldG[line * width + i] = greenA [line * width + i];

oldB[line * width + i] = blueA [line * width + i];

old[line * width + i] = oldR[line * width + i] 16 + oldG[line * width + i] 8 + oldB[line * width + i];

}

当生成新的像素信息后，可以通过java.awt.image.MemoryImageSource包中的MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off, int scan)方法将像素数组对应到图像，并且可以用newPixels()方法来生成新的图像(具体用法可以参考JAVA API DOC)。

memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,

new DirectColorModel(24, 0xff0000, 0x00ff00, 0x0000ff), blocks, 0, imageWidth);

//检查java版本

String javaVersion;

try {

javaVersion = System.getProperty("java.version");

}

catch (SecurityException _ex) {

javaVersion = "unk";

}

if (!javaVersion.startsWith("1.0")) { //jdk1.1以上的版本才支持此方法

try {

memoryimagesource.setAnimated(true);

memoryimagesource.setFullBufferUpdates(true);

imageBuf = createImage(memoryimagesource);

memoryimagesource.newPixels();//生成新的图像

}

catch (NoSuchMethodError _ex) {

System.out.println("unknow java version!");

}

}

到此，新的图像已经产生，只需要输出到屏幕即可。

在此，需要注意以下几个问题：

1、由于Applet读取的图像文件可以比较大，对于速度较慢的网络，可能会造成图像未读取完全就开始进行变换，因此，建议使用MediaTracker方法来保证图像能被顺利载入。

2、 在显示的时候，为了避免闪烁，可以采用双缓冲的方法。

3、 由于在某此高速计算机上，生成新的像素可以非常快，为了避免速度过快而造成效果并不明显，可以加以适当的延时处理。

4、 为了保证效果的平滑，我们特地开辟了非常大的数组来保存像素/RGB信息，这是以空间换时间的做法。

完整的源程序附下(在jdk1.4/2k Server/RedHat9下运行通过，所用机器为P4 2.4G/512M)

package pic;

import java.awt.*;

import java.io.*;

import java.net.*;

import java.awt.event.*;

import java.awt.image.*;

import javax.swing.*;

public class effect

extends JApplet

implements Runnable {

//定义变量

Toolkit toolkit;

int totalBlocks = 0; //图像被分解成的块数，默认为 宽X高

int[] blocks; //保存块数的信息

Image[] bufferImage = new Image[2]; //屏幕上的图形缓冲

VolatileImage offScreenImage;

Image imageBuf; //保存图片缓冲区内容

Graphics2D offScreenGraphics;

Thread thread;

MediaTracker mediaTracker;

boolean[] isImageReady; //图片是否已经装载

MemoryImageSource memoryimagesource;

int imageWidth, imageHeight; //图像的宽及高

int[] pixelA, pixelB;

int[] redA, greenA, blueA, redB, greenB, blueB;

public effect() throws HeadlessException {

bufferImage[0] = getImage("a.jpg");

bufferImage[1] = getImage("b.jpg");

if ( (bufferImage[0].getWidth(this) != bufferImage[1].getWidth(this)) ||

(bufferImage[0].getHeight(this) != bufferImage[1].getHeight(this))) {

System.out.println("图像尺寸不一致！");

return;

}

toolkit = getToolkit();

imageWidth = bufferImage[0].getWidth(this);

imageHeight = bufferImage[0].getHeight(this);

totalBlocks = imageWidth * imageHeight; //计算分解的块数

blocks = new int[totalBlocks];

pixelA = new int[totalBlocks];

pixelB = new int[totalBlocks];

redA = new int[totalBlocks];

greenA = new int[totalBlocks];

blueA = new int[totalBlocks];

redB = new int[totalBlocks];

greenB = new int[totalBlocks];

blueB = new int[totalBlocks];

GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

GraphicsDevice gd = ge.getDefaultScreenDevice();

GraphicsConfiguration gc = gd.getDefaultConfiguration();

offScreenImage = gc.createCompatibleVolatileImage(imageWidth, imageHeight); //创建图像缓冲

offScreenGraphics = offScreenImage.createGraphics(); //取得缓冲的graphics对象

}

public void init() {

getImagePixels(bufferImage[0], pixelA);

getImagePixels(bufferImage[1], pixelB);

for (int i = 0; i totalBlocks; i++) {

blocks[i] = pixelA[i]; //保存图像A的像素信息

redA[i] = pixelA[i] 0xff0000; //保存图像B的red值

greenA[i] = pixelA[i] 0x00ff00; //保存图像B的green值

blueA[i] = pixelA[i] 0x0000ff; //保存图像B的blue值

redB[i] = pixelB[i] 0xff0000; //保存图像B的red值

greenB[i] = pixelB[i] 0x00ff00; //保存图像B的green值

blueB[i] = pixelB[i] 0x0000ff; //保存图像B的blue值

}

prepareImagePixels(); //将像素信息还原为图像

}

public void run() {

//检查java版本

String javaVersion;

try {

javaVersion = System.getProperty("java.version");

}

catch (SecurityException _ex) {

javaVersion = "unk";

}

if (javaVersion.startsWith("1.0")) {

System.out.println("require java 1.1 or later version!");

return;

}

try { //暂停3秒钟后等待效果开始

thread.sleep(3000l);

}

catch (InterruptedException ex1) {

}

int line = 0;

Thread currentThread = Thread.currentThread();

while (line imageHeight thread == currentThread) {

for (int i = 0; i imageWidth; i++) {

int offset = line * imageWidth + i;

blocks[offset] = pixelB[offset]; //与下一被注释的语句作用相同

//blocks[offset] = redB[offset] | greenB[offset] | blueB[offset];

}

memoryimagesource.newPixels(); //生成新的图像

line++;

repaint();

//适当延时

try {

thread.sleep(20l);

}

catch (InterruptedException ex) {

}

}

}

public void paint(Graphics g) {

if (offScreenGraphics != null) { //保证在destory()时不引发异常

offScreenGraphics.drawImage(imageBuf, 0, 0, this);

g.drawImage(offScreenImage, 0, 0, this);

}

}

public void start() {

if (thread == null) {

thread = new Thread(this);

thread.start();

}

}

public void stop() {

thread = null;

}

public final void update(Graphics g) {

paint(g);

}

public void destroy() {

if (offScreenImage != null) {

offScreenImage.flush();

}

offScreenImage = null;

if (offScreenGraphics != null) {

offScreenGraphics.dispose();

}

offScreenGraphics = null;

System.gc();

}

Image getImage(String filename) {

URLClassLoader urlLoader = (URLClassLoader)this.getClass().getClassLoader();

URL url = null;

Image image = null;

url = urlLoader.findResource(filename);

image = Toolkit.getDefaultToolkit().getImage(url);

MediaTracker mediatracker = new MediaTracker(this);

try {

mediatracker.addImage(image, 0);

mediatracker.waitForID(0);

}

catch (InterruptedException _ex) {

image = null;

}

if (mediatracker.isErrorID(0)) {

image = null;

}

return image;

}

private boolean getImagePixels(Image image, int pixels[]) {

PixelGrabber pixelgrabber = new PixelGrabber(image, 0, 0, imageWidth,

imageHeight, pixels,

0, imageWidth);

try {

pixelgrabber.grabPixels();

}

catch (InterruptedException _ex) {

return false;

}

return true;

}

void prepareImagePixels() {

memoryimagesource = new MemoryImageSource(imageWidth, imageHeight,

new DirectColorModel(24, 0xff0000,

0x00ff00, 0x0000ff), blocks, 0, imageWidth);

try {

memoryimagesource.setAnimated(true);

memoryimagesource.setFullBufferUpdates(true);

imageBuf = createImage(memoryimagesource);

memoryimagesource.newPixels(); //生成新的图像

}

catch (NoSuchMethodError _ex) {

}

}

public int getWidth() {

return imageWidth;

}

public int getHeight() {

return imageHeight;

}

public static void main(String args[]) {

JFrame frame = new JFrame("Demo");

effect e = new effect();

e.init();

e.start();

frame.getContentPane().setLayout(new BorderLayout());

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setResizable(false);

frame.getContentPane().add(e);

frame.setSize(new Dimension(e.getWidth() + 6, e.getHeight() + 20));

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dimension frameSize = frame.getSize();

frame.setLocation( (screenSize.width - frameSize.width) / 2,

(screenSize.height - frameSize.height) / 2);

frame.show();

}

}

新建一个HTML文件，加入以下语句可作为Applet(其中width/height分别是图片的高和宽)：

作为应用程序运行的时候，在命令行输入：

java pic.effect

关于像素java和像素射击下载的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。