JAVA扣图组件,JAVA图形组件运行

如何以Java实现网页截图技术

事实上，如果您想以Java实现网页截图，也就是“输入一段网址，几秒钟过后就能截取一张网页缩略图”的效果。那么，您至少有3种方式可以选择。

1、最直接的方式——使用Robot

方法详解：该方法利用Robat提供的强大桌面操作能力，硬性调用浏览器打开指定网页，并将网页信息保存到本地。

优势：简单易用，不需要任何第三方插件。

缺点：不能同时处理大量数据，技术含量过低，属于应急型技巧。

实现方法：使用如下代码即可。

[java] view plaincopy

public static void main(String[] args) throws MalformedURLException,

IOException, URISyntaxException, AWTException {

//此方法仅适用于JdK1.6及以上版本

Desktop.getDesktop().browse(

new URL("").toURI());

Robot robot = new Robot();

robot.delay(10000);

Dimension d = new Dimension(Toolkit.getDefaultToolkit().getScreenSize());

int width = (int) d.getWidth();

int height = (int) d.getHeight();

//最大化浏览器

robot.keyRelease(KeyEvent.VK_F11);

robot.delay(2000);

Image image = robot.createScreenCapture(new Rectangle(0, 0, width,

height));

BufferedImage bi = new BufferedImage(width, height,

BufferedImage.TYPE_INT_RGB);

Graphics g = bi.createGraphics();

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

//保存图片

ImageIO.write(bi, "jpg", new File("google.jpg"));

}

2、最常规的方式——利用JNI，调用第三方C/C++组件

方法详解：目前来讲，Java领域对于网页截图组件的开发明显不足（商机？），当您需要完成此种操作时，算得上碰到了Java的软肋。但是，众所周知Java也拥有强大的JNI能力，可以轻易将C/C++开发的同类组件引为己用。不懂可以扣五七八零二四一四四

优势：实现简单，只需要封装对应的DLL文件，就可以让Java实现同类功能。

劣势：同其他JNI实现一样，在跨平台时存在隐患，而且您的程序将不再属于纯Java应用。

怎么用java实现抠图功能？

package com.thinkgem.jeesite.modules.file.utils;

import com.drew.imaging.ImageMetadataReader;

import com.drew.imaging.ImageProcessingException;

import com.drew.metadata.Directory;

import com.drew.metadata.Metadata;

import com.drew.metadata.Tag;

import javax.imageio.ImageIO;

import javax.swing.*;

import java.awt.*;

import java.awt.image.BufferedImage;

import java.io.*;

public class ImageUtils {

/**

* 图片去白色的背景，并裁切

*

* @param image 图片

* @param range 范围 1-255 越大 容错越高 去掉的背景越多

* @return 图片

* @throws Exception 异常

*/

public static byte[] transferAlpha(Image image, InputStream in, int range) throws Exception {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

try {

ImageIcon imageIcon = new ImageIcon(image);

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());

int alpha = 0;

int minX = bufferedImage.getWidth();

int minY = bufferedImage.getHeight();

int maxX = 0;

int maxY = 0;

for (int j1 = bufferedImage.getMinY(); j1 bufferedImage

.getHeight(); j1++) {

for (int j2 = bufferedImage.getMinX(); j2 bufferedImage

.getWidth(); j2++) {

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

int R = (rgb 0xff0000) 16;

int G = (rgb 0xff00) 8;

int B = (rgb 0xff);

if (((255 - R) range) ((255 - G) range) ((255 - B) range)) { //去除白色背景；

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

} else {

minX = minX = j2 ? minX : j2;

minY = minY = j1 ? minY : j1;

maxX = maxX = j2 ? maxX : j2;

maxY = maxY = j1 ? maxY : j1;

}

bufferedImage.setRGB(j2, j1, rgb);

}

}

int width = maxX - minX;

int height = maxY - minY;

BufferedImage sub = bufferedImage.getSubimage(minX, minY, width, height);

int degree = getDegree(in);

sub = rotateImage(sub,degree);

ImageIO.write(sub, "png", byteArrayOutputStream);

} catch (Exception e) {

e.printStackTrace();

throw e;

}

return byteArrayOutputStream.toByteArray();

}

/**

* 图片旋转

* @param bufferedimage bufferedimage

* @param degree 旋转的角度

* @return BufferedImage

*/

public static BufferedImage rotateImage(final BufferedImage bufferedimage,

final int degree) {

int w = bufferedimage.getWidth();

int h = bufferedimage.getHeight();

Rectangle rect_des = CalcRotatedSize(new Rectangle(new Dimension(

w, h)), degree);

int type = bufferedimage.getColorModel().getTransparency();

BufferedImage img;

Graphics2D graphics2d;

(graphics2d = (img = new BufferedImage(rect_des.width, rect_des.height, type))

.createGraphics()).setRenderingHint(

RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BILINEAR);

graphics2d.translate((rect_des.width - w) / 2,

(rect_des.height - h) / 2);

graphics2d.rotate(Math.toRadians(degree), w / 2, h / 2);

graphics2d.drawImage(bufferedimage, 0, 0, null);

graphics2d.dispose();

return img;

}

/**

* 计算旋转后图像的大小

* @param src Rectangle

* @param degree 旋转的角度

* @return Rectangle

*/

public static Rectangle CalcRotatedSize(Rectangle src, int degree) {

if (degree = 90) {

if(degree / 90 % 2 == 1){

int temp = src.height;

src.height = src.width;

src.width = temp;

}

degree = degree % 90;

}

double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;

double len = 2 * Math.sin(Math.toRadians(degree) / 2) * r;

double angel_alpha = (Math.PI - Math.toRadians(degree)) / 2;

double angel_dalta_width = Math.atan((double) src.height / src.width);

double angel_dalta_height = Math.atan((double) src.width / src.height);

int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha

- angel_dalta_width));

int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha

- angel_dalta_height));

int des_width = src.width + len_dalta_width * 2;

int des_height = src.height + len_dalta_height * 2;

return new java.awt.Rectangle(new Dimension(des_width, des_height));

}

/**

* byte[] ------BufferedImage

*

* @param byteImage byteImage

* @return return

* @throws IOException IOException

*/

public static BufferedImage ByteToBufferedImage(byte[] byteImage) throws IOException {

ByteArrayInputStream in = new ByteArrayInputStream(byteImage);

return ImageIO.read(in);

}

/**

* 获取照片信息的旋转角度

* @param inputStream 照片的路径

* @return 角度

*/

public static int getDegree(InputStream inputStream) {

try {

Metadata metadata = ImageMetadataReader.readMetadata(new BufferedInputStream(inputStream),true);

for (Directory directory : metadata.getDirectories()) {

for (Tag tag : directory.getTags()) {

if ("Orientation".equals(tag.getTagName())) {

return turn(getOrientation(tag.getDescription()));

}

}

}

} catch (ImageProcessingException e) {

e.printStackTrace();

return 0;

} catch (IOException e) {

e.printStackTrace();

return 0;

}

return 0;

}

/**

* 获取旋转的角度

* @param orientation orientation

* @return 旋转的角度

*/

public static int turn(int orientation) {

Integer turn = 360;

if (orientation == 0 || orientation == 1) {

turn = 360;

} else if (orientation == 3) {

turn = 180;

} else if (orientation == 6) {

turn = 90;

} else if (orientation == 8) {

turn = 270;

}

return turn;

}

/**

* 根据图片自带的旋转的信息 获取 orientation

* @param orientation orientation

* @return orientation

*/

public static int getOrientation(String orientation) {

int tag = 0;

if ("Top, left side (Horizontal / normal)".equalsIgnoreCase(orientation)) {

tag = 1;

} else if ("Top, right side (Mirror horizontal)".equalsIgnoreCase(orientation)) {

tag = 2;

} else if ("Bottom, right side (Rotate 180)".equalsIgnoreCase(orientation)) {

tag = 3;

} else if ("Bottom, left side (Mirror vertical)".equalsIgnoreCase(orientation)) {

tag = 4;

} else if ("Left side, top (Mirror horizontal and rotate 270 CW)".equalsIgnoreCase(orientation)) {

tag = 5;

} else if ("Right side, top (Rotate 90 CW)".equalsIgnoreCase(orientation)) {

tag = 6;

} else if ("Right side, bottom (Mirror horizontal and rotate 90 CW)".equalsIgnoreCase(orientation)) {

tag = 7;

} else if ("Left side, bottom (Rotate 270 CW)".equalsIgnoreCase(orientation)) {

tag = 8;

}

return tag;

}

}

如何用Java 实现抠图？

选中你想抠图的图片,右键,选中编辑选项,进入"画图"程序

2、按住"Ctrl+A",选中图片,"Ctrl+C"复制图片