Java Examples for javax.imageio.ImageIO

public static void main(String[] args) {
    try {
        BufferedImage image = javax.imageio.ImageIO.read(new File("/logs/orginal.jpg"));
        BufferedImage scaledImage = Scalr.resize(image, 60);
        javax.imageio.ImageIO.write(scaledImage, "JPG", new File("/logs/output1.jpg"));
        BufferedImage image2 = javax.imageio.ImageIO.read(new File("/logs/orginal2.png"));
        BufferedImage scaledImage2 = Scalr.resize(image2, 60);
        javax.imageio.ImageIO.write(scaledImage2, "PNG", new File("/logs/output2.png"));
        BufferedImage image3 = javax.imageio.ImageIO.read(new File("/logs/orginal2.png"));
        BufferedImage croppedImage3 = image3.getSubimage(300, 200, 600, 300);
        javax.imageio.ImageIO.write(croppedImage3, "PNG", new File("/logs/output3.png"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Before("call(* javax.imageio.ImageIO.read(java.io.InputStream)) && args(in)")
public void read(JoinPoint thisJoinPoint, InputStream in) {
    final ReactiveAuditException ex = AbstractInputStreamAudit.latencyInputStream(config, HIGH, thisJoinPoint, in);
    if (ex != null)
        super.logLatency(HIGH, thisJoinPoint, new ExceptionFactory() {

            public ReactiveAuditException lazyException() {
                return ex;
            }
        });
}

@Override
public BufferedImage load(File file) throws ImageDifferException {
    BufferedImage image = null;
    try {
        image = ImageIO.read(file);
    } catch (IOException e) {
        throw new ImageDifferException(ImageDifferException.ErrorCode.IMAGE_READ_ERROR, String.format("Error reading image: %s", file.getAbsolutePath()), e);
    }
    return image;
}

public BufferedImage getEditImage() {
    if (fieldEditImage == null) {
        InputStream in = null;
        try {
            in = getEditPage().getContentItem().getInputStream();
            fieldEditImage = ImageIO.read(in);
        } catch (Exception ex) {
            throw new OpenEditRuntimeException(ex);
        } finally {
            FileUtils.safeClose(in);
        }
    }
    return fieldEditImage;
}

public static Image loadImage(String path) {
    Image image = null;
    if (cache.containsKey(path)) {
        return cache.get(path);
    }
    try {
        image = ImageIO.read(new File(path));
        if (!cache.containsKey(path)) {
            cache.put(path, image);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return image;
}

public static Image getProgramIcon() {
    //initialize the icons used in the program
    URL programIconURL = GUICommon.class.getResource("/res/AppIcon.png");
    //Used for icon in the title bar
    Image programIcon = null;
    try {
        programIcon = ImageIO.read(programIconURL);
    } catch (IOException e1) {
        e1.printStackTrace();
    }
    return programIcon;
}

public static void main(String[] args) throws IOException {
    for (String arg : args) {
        File f = new File(arg);
        FileInputStream in = new FileInputStream(f);
        Region r = Region.read(new DataInputStream(in));
        in.close();
        BufferedImage img = r.toBufferedImage();
        ImageIO.write(img, "png", new File(f.getParentFile(), f.getName() + ".png"));
    }
}

public static byte[] resizeAndCropImage(BufferedImage img, int imageCropWidthPixels, int imageCropHeightPixels) throws IOException {
    FileUploadUtilHelper helper = new FileUploadUtilHelper(img);
    BufferedImage resImg = helper.resizeImage(imageCropWidthPixels, imageCropHeightPixels);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    if (helper.getContainsTransparency()) {
        ImageIO.write(resImg, "png", bos);
    } else {
        ImageIO.write(resImg, "jpg", bos);
    }
    return bos.toByteArray();
}

public static void testCaptureDevice() {
    CaptureDevice cd = new CaptureDevice();
    cd.getMonitors().stream().forEach( m -> System.out.println(m.getBounds()));
    BufferedImage c = cd.captureMonitors(cd.getMonitors());
    try {
        File file = new File("C:\\Users\\connorelsea\\Desktop\\image.png");
        ImageIO.write(c, "png", file);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

protected static JLabel getImage(String filename) {
    BufferedImage myPicture = null;
    try {
        //myPicture = ImageIO.read(new File(filename));
        System.out.println("get ressource (" + filename + ")=>" + Utils.class.getResource(filename));
        myPicture = ImageIO.read(new File(Utils.class.getResource(filename).getFile()));
    } catch (IOException e) {
        e.printStackTrace();
    }
    JLabel picLabel = new JLabel(new ImageIcon(myPicture));
    return picLabel;
}

private static Icon createIcon(String iconFile, int scaleSize) {
    File imageFile = new File(iconFile);
    try {
        Image originalImage = ImageIO.read(imageFile);
        if (scaleSize > 0) {
            Image resizedImage = originalImage.getScaledInstance(scaleSize, scaleSize, Image.SCALE_DEFAULT);
            return new ImageIcon(resizedImage);
        } else {
            return new ImageIcon(originalImage);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

public static void main(String[] args) throws Exception {
    ApplyALicense.applyALicense();
    // The path to the resource directory.
    String dataDir = Utils.getDataDir(SpecificBarcodeSymbology.class) + "BarcodeReader/basic_features/";
    BufferedImage img = ImageIO.read(new File(dataDir + "CodeText.jpg"));
    // Initialize barcode reader
    BarCodeReader rd = new BarCodeReader(img, BarCodeReadType.Code128);
    // Read barcode of type Code39Extended
    while (rd.read()) {
        // Print the code text, if barcode found
        System.out.println("CodeText: " + rd.getCodeText().toString());
        // Print the symbology type
        System.out.println("CodeText: " + rd.getReadTypeName());
    }
}

public static void main(String[] args) throws Exception {
    // The path to the documents directory.
    String dataDir = Utils.getDataDir(AsposeThumbnail.class);
    // Instantiate a Presentation class that represents the PPTX file
    Presentation pres = new Presentation(dataDir + "presentation.pptx");
    // Access the first slide
    ISlide sld = pres.getSlides().get_Item(0);
    // Create a full scale image
    BufferedImage image = sld.getThumbnail(1f, 1f);
    // Save the image to disk in JPEG format
    ImageIO.write(image, "jpeg", new File(dataDir + "AsposeThumbnail.jpg"));
    // Printing the status
    System.out.println("Thumbnail created successfully!");
}

public static Image loadImage(Class clazz, String path, int width, int height) {
    Image image = null;
    try {
        BufferedImage tempimage = ImageIO.read(clazz.getResourceAsStream(path));
        image = tempimage.getScaledInstance(width, height, Image.SCALE_FAST);
    } catch (IOException ex1) {
        Logger.getLogger(ImageUtil.class.getName()).log(Level.SEVERE, null, ex1);
    }
    return image;
}

public static String imageToBase64(BufferedImage b) {
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    OutputStream b64 = new Base64.OutputStream(os);
    try {
        ImageIO.write(b, "PNG", b64);
        return ("data:image/png;base64," + os.toString("UTF-8"));
    } catch (IOException e) {
        log.error("Failed", e);
        return "Failed";
    }
}

@Test
public void test() throws IOException {
    ZxingBuilder builder = ZxingUtils.builder();
    ByteArrayOutputStream bao = new ByteArrayOutputStream();
    builder.buildEncoder("hoge").encode(bao);
    assertTrue(builder.buildEncoder("hoge").encode() instanceof BufferedImage);
    BufferedImage image = ImageIO.read(new ByteArrayInputStream(bao.toByteArray()));
    BufferedImageDecodeArguments arg = new BufferedImageDecodeArguments(image);
    assertNotEquals("foo", builder.buildDecoder().decode(arg));
    assertEquals("hoge", builder.buildDecoder().decode(arg));
}

/**
	 * �存图片
	 * @param image 内存中的图片对象
	 * @param target �存的目标文件
	 * @throws IOException 文件写入异常
	 */
public static void saveImage(BufferedImage image, File target) throws IOException {
    //		FileOutputStream out = new FileOutputStream(imgdist);
    //		JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
    //		encoder.encode(tag);
    //		out.close();
    String filePath = target.getAbsolutePath();
    String formatName = filePath.substring(filePath.lastIndexOf(".") + 1);
    ImageIO.write(image, formatName, target);
}

/**
	 * @param args
	 */
public static void main(String[] args) throws Exception {
    BufferedImage mask = ImageIO.read(new File("/tmp/image5.bmp"));
    BufferedImage img = ImageIO.read(new File("/home/remco/data/map/World.bmp"));
    int[] maskArray = new int[10800 * 5400];
    mask.getRGB(0, 0, 10800, 5400, maskArray, 0, 10800);
    int[] rgbArray = new int[10800 * 5400];
    img.getRGB(0, 0, 10800, 5400, rgbArray, 0, 10800);
    int k = 0;
    for (int i = 0; i < 10800; i++) {
        for (int j = 0; j < 5400; j++) {
            if ((maskArray[k] & 0xffffff) == 0xff) {
                rgbArray[k] = 0x85a5ab;
            }
            k++;
        }
    }
    img.setRGB(0, 0, 10800, 5400, rgbArray, 0, 10800);
    ImageIO.write(img, "bmp", new File("/tmp/world.bmp"));
}

/**
	 * 
	 * @param source
	 * @param dest
	 * @param encoding
	 * @param width
	 * @param height
	 * @throws IOException
	 */
public static void scaleImage(File source, File dest, String encoding, int width, int height) throws IOException {
    BufferedImage srcImage = ImageIO.read(source);
    BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    Graphics2D g = destImage.createGraphics();
    AffineTransform at = AffineTransform.getScaleInstance((double) width / srcImage.getWidth(), (double) height / srcImage.getHeight());
    g.drawRenderedImage(srcImage, at);
    ImageIO.write(destImage, encoding, dest);
}

@Test
public void optimizeImage() {
    BufferedImage img = null;
    try {
        img = ImageIO.read(EngineAlpha.class.getResource("/assets/logo.png"));
    } catch (Exception e) {
        Logger.error(e.getLocalizedMessage());
    }
    assertNotNull(img);
    BufferedImage opt = Optimizer.toCompatibleImage(img);
    assertNotNull(opt);
    assertEquals(img.getWidth(), opt.getWidth());
    assertEquals(img.getHeight(), opt.getHeight());
    BufferedImage opt2 = Optimizer.toCompatibleImage(opt);
    assertEquals(opt.getColorModel(), opt2.getColorModel());
}

public static void main(String[] args) throws Exception {
    BufferedImage image = (BufferedImage) ImageIO.read(ImgeTest.class.getResourceAsStream("/img.jpg"));
    int width = image.getWidth(), height = image.getHeight(), r = image.getWidth() / 2 + 20, rx = image.getWidth() / 2, ry = image.getHeight() / 2;
    System.out.println("width : " + width + ", height : " + height);
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int temp = (x - rx) * (x - rx) + (y - ry) * (y - ry);
            if (temp > (r * r)) {
                image.setRGB(x, y, 0);
            }
        }
    }
}

/**
	 * Gets an image from the Database
	 */
private void getImagefromDB() {
    //TODO get from the database
    try {
        //the byte array to be retrieved from the database
        byte[] imgbytes = new byte[10];
        //perform the select
        //the byte array input stream
        InputStream bis = new ByteArrayInputStream(imgbytes);
        image.setImage(ImageIO.read(bis));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void testname() throws Exception {
    System.out.println(Arrays.asList(ImageIO.getReaderMIMETypes()));
    System.out.println(Arrays.asList(ImageIO.getWriterFormatNames()));
    System.out.println(Arrays.asList(ImageIO.getReaderFormatNames()));
    URL pngFile = getClass().getResource("/test.png");
    BufferedImage img = ImageIO.read(pngFile);
    for (String type : ImageIO.getWriterFormatNames()) {
        if (type.equalsIgnoreCase("jpg") || type.equalsIgnoreCase("jpeg")) {
            // Avoid issue #6 on OpenJDK8/Debian 
            continue;
        }
        File f = File.createTempFile("imageio-test", "." + type);
        ImageIO.write(img, type, f);
        System.out.println(f);
        ImageIO.read(f);
    }
}

@Test
public void sanityTestLocal() throws IOException {
    ImageUtils imageUtils = new ImageUtils();
    assertNotNull(imageUtils);
    BufferedImage bufferedImage = ImageIO.read(new File(Utils.getAppRoot() + "/src/test/resources/dtpick.gif"));
    String hexa = ImageUtils.getImageHexaBase64(bufferedImage, "gif");
    assertEquals(1, TestUtils.regexCount(hexa, "R0lGODlhEAAQAPMAAKVNSkpNpUpNSqWmpdbT1v"));
}

public void test(int width) {
    try {
        File sourceImageFile = new File("bigfile.jpg");
        BufferedImage sourceImage = ImageIO.read(sourceImageFile);
        Image thumbnail = sourceImage.getScaledInstance(width, -1, Image.SCALE_SMOOTH);
        BufferedImage bufferedThumbnail = new BufferedImage(thumbnail.getWidth(null), thumbnail.getHeight(null), BufferedImage.TYPE_INT_RGB);
        bufferedThumbnail.getGraphics().drawImage(thumbnail, 0, 0, null);
    //ImageIO.write(bufferedThumbnail, "jpeg", outputStream);
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

/**
	 * @param args
	 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    File outFile = new File("hoge.avi");
    try {
        AviWriter aviWriter = new AviWriter(outFile, 2, true);
        for (int i = 1; i < 5; i++) {
            BufferedImage bi = ImageIO.read(new File("/home/igawa/Dropbox/Pictures/NEC_004" + i + ".JPG"));
            aviWriter.writeFrame(bi);
        }
        aviWriter.setFramesPerSecond(1, 1);
        aviWriter.setSamplesPerSecond(1);
        aviWriter.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws Exception {
    PDFJob job = new PDFJob(new FileOutputStream("test.pdf"));
    PageFormat pf = new PageFormat();
    pf.setOrientation(PageFormat.PORTRAIT);
    Paper p = new Paper();
    //A4
    p.setSize(210, 297);
    pf.setPaper(p);
    BufferedImage img = ImageIO.read(new File("earth.jpg"));
    int w = 200;
    for (int i = 0; i < 10; i++) {
        Graphics g = job.getGraphics();
        g.drawImage(img, 0, 0, w, w, null);
        g.dispose();
    }
    job.end();
}

public static void openSheet() {
    TextureBinder tex = new TextureBinder(SpriteSheet.class.getResourceAsStream("/tileset.png"), tileSheet);
    tex.equals(null);
    BufferedImage image = null;
    try {
        image = ImageIO.read(SpriteSheet.class.getResourceAsStream("/tileset.png"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    if (image == null) {
        return;
    }
    width = image.getWidth();
    height = image.getHeight();
}

@Override
public SegmentableIcyBufferedImage load(File f) throws IOException {
    IcyBufferedImage ibi = null;
    if (isUseLoci()) {
        try {
            ibi = Loader.loadImage(f);
        } catch (UnsupportedFormatException e) {
            throw new IOException(e);
        }
    } else {
        ibi = IcyBufferedImage.createFrom(ImageIO.read(f));
    }
    return new SegmentableIcyBufferedImage(ibi);
}

public static void main(final String[] pArgs) throws IOException {
    PICTImageReaderSpi provider = new PICTImageReaderSpi();
    if (pArgs.length == 0) {
        System.exit(1);
    }
    for (String arg : pArgs) {
        boolean canDecode = provider.canDecodeInput(ImageIO.createImageInputStream(new File(arg)));
        System.err.printf("canDecode %s: %s%n", arg, canDecode);
    }
}

@Override
public SwingBitmap load(String name, int tileSize) {
    reAssert(Arrays.binarySearch(SIZES, tileSize) >= 0);
    String resourcePath = "/rabbitescape/ui/swing/images" + tileSize + "/" + name + ".png";
    try {
        return new SwingBitmap(name, javax.imageio.ImageIO.read(getClass().getResource(resourcePath)));
    } catch (IOExceptionIllegalArgumentException |  e) {
        throw new FailedToLoadImage(resourcePath, e);
    }
}

public static Point getImageSizeFromStream(InputStream is) {
    if (!initialized) {
        // Stops ImageIO from creating temp files when reading images
        // from input stream.
        ImageIO.setUseCache(false);
        initialized = true;
    }
    try {
        ImageInputStream imageStream = ImageIO.createImageInputStream(is);
        Iterator<ImageReader> readers = ImageIO.getImageReaders(imageStream);
        if (!readers.hasNext())
            return null;
        ImageReader reader = readers.next();
        try {
            reader.setInput(imageStream);
            return new Point(reader.getWidth(0), reader.getHeight(0));
        } finally {
            reader.dispose();
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

static void save(final BufferedImage image, final File file, final String imageFormat) {
    // this is an ugly workaround to achieve 100% coverage (the pesky
    // IOException catch)
    // The performance hit of making this allocation should be negligible
    // compared to the cost of IO
    Callable<Void> callable = new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            ImageIO.write(image, imageFormat, file);
            return null;
        }
    };
    run(callable);
}

public static void main(String[] arg) throws SlideExecutionException, IOException {
    // display a mock image of an emulator
    Canvas canvas = new DesktopCanvas();
    canvas.addImage(new DefaultLocation(100, 100), ImageIO.read(Resources.emulator_png));
    canvas.show();
    // execute a series of click operations defined in "emulator.pptx"
    Slides.execute(Resources.emulator_pptx);
    // hide the mock image
    canvas.hide();
}

public static void main(String[] args) {
    String path = "images/Mandrill.bmp";
    try {
        BufferedImage image = ImageIO.read(new File(path));
        int width = image.getWidth();
        int height = image.getHeight();
        int[] pixels = image.getRGB(0, 0, width, height, null, 0, width);
        byte[] buffer = TGAWriter.write(pixels, width, height, TGAReader.ARGB);
        FileOutputStream fos = new FileOutputStream(path.replace(".bmp", ".tga"));
        fos.write(buffer);
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(final String[] pArgs) throws IOException {
    PICTImageReaderSpi provider = new PICTImageReaderSpi();
    if (pArgs.length == 0) {
        System.exit(1);
    }
    for (String arg : pArgs) {
        boolean canDecode = provider.canDecodeInput(ImageIO.createImageInputStream(new File(arg)));
        System.err.printf("canDecode %s: %s%n", arg, canDecode);
    }
}

@Test
public final void runTestCase() throws IOException {
    // load the image into the data array
    BufferedImage imgIn = ImageIO.read(new File("test.png"));
    short[][] matrix = new short[imgIn.getWidth()][imgIn.getHeight()];
    for (int x = 0; x < imgIn.getWidth(); x++) {
        for (int y = 0; y < imgIn.getHeight(); y++) {
            //System.out.println(img.getRGB(x,y));
            matrix[x][y] = (short) (imgIn.getRGB(x, y) != -1 ? 1 : 0);
        }
    }
    Rectangle rect = MaxRectFinder.maximalRectangle(matrix);
    System.out.println(rect);
}

public static void main(String[] args) throws Throwable {
    // get default camera
    Webcam webcam = Webcam.getDefault();
    // set VGA resolution and open
    webcam.setViewSize(WebcamResolution.VGA.getSize());
    webcam.open();
    // get image
    BufferedImage image = webcam.getImage();
    // close camera
    webcam.close();
    // save image to file
    ImageIO.write(image, "PNG", new File("bubu.png"));
}

/**
	 * Load an image easily
	 * @param path Path to Image
	 * @return Image
	 */
public Image loadGraphic(String path) {
    BufferedImage img = null;
    try {
        img = ImageIO.read(getClass().getResourceAsStream(defDir + path));
    } catch (Exception e) {
        Log.err("Yamanu: " + e.getMessage());
        Log.err("Yamanu Version: " + util.getYGEVersion());
        e.printStackTrace();
    }
    return img;
}

public static byte[] transform(File originalFile, int thumbWidth, int thumbHeight) throws Exception {
    BufferedImage image = javax.imageio.ImageIO.read(originalFile);
    double thumbRatio = (double) thumbWidth / (double) thumbHeight;
    int imageWidth = image.getWidth(null);
    int imageHeight = image.getHeight(null);
    double imageRatio = (double) imageWidth / (double) imageHeight;
    if (thumbRatio < imageRatio) {
        thumbHeight = (int) (thumbWidth / imageRatio);
    } else {
        thumbWidth = (int) (thumbHeight * imageRatio);
    }
    if (imageWidth < thumbWidth && imageHeight < thumbHeight) {
        thumbWidth = imageWidth;
        thumbHeight = imageHeight;
    } else if (imageWidth < thumbWidth)
        thumbWidth = imageWidth;
    else if (imageHeight < thumbHeight)
        thumbHeight = imageHeight;
    BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);
    Graphics2D graphics2D = thumbImage.createGraphics();
    graphics2D.setBackground(Color.WHITE);
    graphics2D.setPaint(Color.WHITE);
    graphics2D.fillRect(0, 0, thumbWidth, thumbHeight);
    graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    javax.imageio.ImageIO.write(thumbImage, "JPG", baos);
    return baos.toByteArray();
}

public void waterMark(String strOriginalFileName, String strWaterMarkFileName) {
    try {
        //String root=session.getServletContext().getRealPath("/");
        //File fileOriginal = new File(root+strOriginalFileName);
        File fileOriginal = new File(strOriginalFileName);
        Image imageOriginal = ImageIO.read(fileOriginal);
        int widthOriginal = imageOriginal.getWidth(null);
        int heightOriginal = imageOriginal.getHeight(null);
        System.out.println("widthOriginal:" + widthOriginal + "theightOriginal:" + heightOriginal);
        BufferedImage bufImage = new BufferedImage(widthOriginal, heightOriginal, BufferedImage.TYPE_INT_RGB);
        Graphics g = bufImage.createGraphics();
        g.drawImage(imageOriginal, 0, 0, widthOriginal, heightOriginal, null);
        //File fileWaterMark = new File(root+strWaterMarkFileName);
        File fileWaterMark = new File(strWaterMarkFileName);
        Image imageWaterMark = ImageIO.read(fileWaterMark);
        int widthWaterMark = imageWaterMark.getWidth(null);
        int heightWaterMark = imageWaterMark.getHeight(null);
        System.out.println("widthWaterMark:" + widthWaterMark + "theightWaterMark:" + heightWaterMark);
        g.drawImage(imageWaterMark, widthOriginal - widthWaterMark, heightOriginal - heightWaterMark, widthWaterMark, heightWaterMark, null);
        g.dispose();
        //FileOutputStream fos = new FileOutputStream( root+strOriginalFileName);
        FileOutputStream fos = new FileOutputStream(strOriginalFileName);
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(fos);
        encoder.encode(bufImage);
        fos.flush();
        fos.close();
        fos = null;
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public MagicGame getGame() {
    for (final MagicCardDefinition cdef : CardDefinitions.getAllCards()) {
        final BufferedImage buffImg = CardBuilder.getCardBuilderImage(cdef);
        int[] data = ((DataBufferInt) buffImg.getData().getDataBuffer()).getData();
        int hash = Arrays.hashCode(data);
        System.out.println(cdef.getDistinctName() + "\t" + hash);
        if (cdef.getDistinctName().contains("QQQ")) {
            try {
                File outputfile = new File(cdef.getImageName() + ".png");
                ImageIO.write(buffImg, "png", outputfile);
            } catch (IOException e) {
                System.out.println("saving " + cdef.getDistinctName() + " failed");
            }
        }
    }
    final MagicDuel duel = createDuel(MagicAIImpl.MCTS, 6);
    final MagicGame game = duel.nextGame();
    return game;
}

public void run() {
    while (this.active) {
        try {
            if (players.isEmpty()) {
                Thread.sleep(50L);
            } else {
                MapObjectPlayer p = players.pop();
                try {
                    URL url = new URL("http://s3.amazonaws.com/MinecraftSkins/" + p.getName() + ".png");
                    BufferedImage img = ImageIO.read(url);
                    BufferedImage pimg = new BufferedImage(20, 20, BufferedImage.TYPE_INT_ARGB);
                    Graphics2D g2d = pimg.createGraphics();
                    g2d.setColor(Color.black);
                    g2d.fillRect(0, 0, 20, 20);
                    g2d.drawImage(img, 2, 2, 18, 18, 8, 8, 16, 16, null);
                    g2d.dispose();
                    img.flush();
                    p.setMarker(pimg);
                    Thread.sleep(20L);
                } catch (MalformedURLException e2) {
                } catch (IOException e) {
                }
            }
        } catch (InterruptedException e) {
        }
    }
    if (!this.active) {
        dispose();
    }
}

public String index() throws IOException {
    String captchaId = request.getSession().getId();
    BufferedImage challenge = captchaService.getImageChallengeForID(captchaId, getLocale());
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    ImageIO.write(challenge, "JPEG", os);
    setInputStream(new ByteArrayInputStream(os.toByteArray()));
    return "success";
}

/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    HttpSession session = request.getSession(true);
    /*
		 * Create CAPTCHA.
		 */
    BufferedImage bImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
    // Set whether HSTS is enabled.
    session.setAttribute("HstsEnabled", request.isSecure());
    // Prevent from caching
    response.setHeader("Cache-Control", "private, no-store, no-cache, must-revalidate");
    response.setHeader("Pragma", "no-cache");
    // Return image
    response.setContentType("image/png");
    ImageIO.write(bImage, "png", response.getOutputStream());
}

private void write(BufferedImage image) {
    if (path != null) {
        File file = new File(String.format("%s/%d.png", path, sequence++));
        try {
            ImageIO.write(image, "png", file);
        } catch (IOException e) {
            System.err.println("Error writing image " + file.getPath() + ": " + e.getMessage());
        }
    }
}

@Test
public void testSaveThumb() throws IOException {
    File img = new File("testdata/cbir.png");
    assertThat(img.exists()).isTrue();
    File file = storeImageService.saveIndexImage(123l, ImageIO.read(img));
    assertThat(file.exists()).isTrue();
    BufferedImage image = storeImageService.readIndexImage(123l);
    assertThat(image).isNotNull();
}

public BufferedImage load(ScreenShot shot) {
    try {
        File file = new File(props.getSessionsDirPath() + shot.getSession().getName() + File.separator + shot.getFilename());
        return ImageIO.read(file);
    } catch (IOException e) {
        log.error(ErrorMsgs.SCREENSHOT_LOAD_IMAGE_ERROR, e);
        ErrorNotifier.notify(ErrorMsgs.SCREENSHOT_LOAD_IMAGE_ERROR);
        return null;
    }
}

@Override
public void serve(HttpServletRequest request, HttpServletResponse response) throws IOException {
    BufferedImage bufferedImage = new BufferedImage(40, 40, BufferedImage.TYPE_INT_RGB);
    //Draw an oval
    Graphics g = bufferedImage.getGraphics();
    g.setColor(Color.white);
    g.fillRect(0, 0, 50, 50);
    g.setColor(Color.pink);
    g.fillOval(0, 0, 39, 39);
    g.setFont(new Font("SansSerif", Font.PLAIN, 11));
    g.setColor(Color.black);
    g.drawString(name, 10, 24);
    g.dispose();
    response.setContentType("image/jpeg");
    ImageIO.write(bufferedImage, "jpg", response.getOutputStream());
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("image/jpeg");
    // 设置页��缓存
    response.setHeader("Pragma", "No-cache");
    response.setHeader("Cache-Control", "no-cache");
    response.setDateHeader("Expires", 0);
    BufferedImage image = CodeBuilder.buildCode(4, request, VERITY_CODE_KEY);
    // 输出图象到页�
    ImageIO.write(image, "JPEG", response.getOutputStream());
}

public Icon getIcon(File f) {
    String extention = Utils.getExtention(f.getName());
    if (extention != null) {
        if (extention.equalsIgnoreCase("png") || extention.equalsIgnoreCase("tiff") || extention.equalsIgnoreCase("tif") || extention.equalsIgnoreCase("gif") || extention.equalsIgnoreCase("bmp") || extention.equalsIgnoreCase("jpeg") || extention.equalsIgnoreCase("jpg")) {
            try {
                BufferedImage original = ImageIO.read(f);
                BufferedImage resized = new BufferedImage(16, 16, original.getType());
                Graphics2D g = resized.createGraphics();
                g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
                g.drawImage(original, 0, 0, 16, 16, 0, 0, original.getWidth(), original.getHeight(), null);
                g.dispose();
                return new ImageIcon(resized);
            } catch (Exception e) {
                return super.getIcon(f);
            }
        } else {
            return super.getIcon(f);
        }
    } else {
        return super.getIcon(f);
    }
}

public byte[] getImageForText(String[] text, Color foreground, Color background, Font font, int width, int height, int offSetX, int offSetY, ImageFileFormat format) throws IOException {
    BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    Graphics2D grph = img.createGraphics();
    grph.setFont(font);
    grph.setColor(foreground);
    grph.setBackground(background);
    grph.clearRect(0, 0, width, height);
    int y = 0;
    for (String s : text) {
        grph.drawString(s, offSetX, offSetY + y);
        y += font.getSize() + 2;
    }
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    ImageIO.write(img, format.getValue(), os);
    os.close();
    return os.toByteArray();
}

private void assertBI(File file, int[] firstPixel, final int expectedComponentCount) {
    BufferedImage image = null;
    try {
        image = ImageIO.read(file);
    } catch (IOException e) {
        e.printStackTrace();
    }
    assertEquals("component count", expectedComponentCount, image.getColorModel().getNumComponents());
    byte[] newPixels = ByteBufferedImage.convertBIintoARGBArray(image);
    assertEquals("length", image.getWidth() * image.getHeight() * 4, newPixels.length);
    assertEquals("first pixel a", firstPixel[0], (newPixels[0] & 0xFF));
    assertEquals("first pixel r", firstPixel[1], (newPixels[1] & 0xFF));
    assertEquals("first pixel g", firstPixel[2], newPixels[2]);
    assertEquals("first pixel b", firstPixel[3], newPixels[3]);
}

public static void compareImages(String imageName, BufferedImage image) throws Exception {
    boolean done = false;
    try {
        BufferedImage expected = ImageIO.read(ImageAssert.class.getResource(imageName + ".png"));
        assertEquals("Images are not the same height", expected.getHeight(), image.getHeight());
        assertEquals("Images are not the same width", expected.getWidth(), image.getWidth());
        for (int x = 0; x < image.getWidth(); x++) {
            for (int y = 0; y < image.getHeight(); y++) {
                assertEquals(expected.getRGB(x, y), image.getRGB(x, y));
            }
        }
        done = true;
    } finally {
        if (!done) {
            ImageIO.write(image, "png", new File("src/test/resources/org/diirt/graphene/" + imageName + ".failed.png"));
        } else {
            File file = new File("src/test/resources/org/diirt/graphene/" + imageName + ".failed.png");
            if (file.exists()) {
                file.delete();
            }
        }
    }
}

private void setImage() {
    try {
        BufferedImage img = ImageIO.read(getClass().getResource(src));
        title.setIcon(new ImageIcon(img.getScaledInstance(title.getWidth(), -1, Image.SCALE_FAST)));
        title.setHorizontalAlignment(JLabel.CENTER);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

static ImageIcon createImageIcon(String iconName) {
    ImageIcon result = null;
    String fullIconPath = "/viewer/icons/" + iconName + ".png";
    try {
        Image image = ImageIO.read(ViewerUtil.class.getResourceAsStream(fullIconPath));
        result = new ImageIcon(image);
    } catch (Exception e) {
        log.error("Icon \'" + fullIconPath + "\' not found");
    }
    return result;
}

@Override
public void execute(StormTaskTuple t) {
    try {
        // fetch the image from the input tuple
        ByteArrayInputStream inputImage = t.getFileByteDataAsStream();
        BufferedImage bufferedImage = ImageIO.read(inputImage);
        OutputStream os = new ByteArrayOutputStream();
        // transcoding to jpeg
        ImageIO.write(bufferedImage, "jpg", os);
        t.setFileData(os.toString().getBytes(Charset.forName("UTF-8")));
        //emitting to the next bolt
        outputCollector.emit("stream-to-next-bolt", t.toStormTuple());
    } catch (IOException ex) {
        this.emitErrorNotification(t.getTaskId(), t.getFileUrl(), ex.getMessage(), "");
        outputCollector.fail(inputTuple);
    }
}

public void paint(Graphics g) {
    super.paint(g);
    BufferedImage image;
    try {
        image = ImageIO.read(Main.class.getClass().getResource("/de/zigapeda/flowspring/res/splashscreen.png"));
        g.drawImage(image, 1, 1, null);
        g.drawRect(0, 0, 301, 201);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private static boolean[][] generateMask(String location) throws IOException {
    URL u = ImageUtil.class.getResource(location);
    BufferedImage buf = ImageIO.read(u);
    boolean[][] rv = new boolean[buf.getWidth()][buf.getHeight()];
    for (int i = 0; i < buf.getWidth(); i++) {
        for (int j = 0; j < buf.getHeight(); j++) {
            if (new Color(buf.getRGB(i, j)).getAlpha() != 0) {
                rv[i][j] = true;
            }
        }
    }
    return rv;
}

public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
    res.setHeader("Cache-Control", "max-age=86400");
    String name = req.getParameter("name");
    name = "images/" + name + ".png";
    InputStream imageStream = DefaultIconSet.class.getResourceAsStream(name);
    ServletOutputStream out = res.getOutputStream();
    BufferedImage image = ImageIO.read(imageStream);
    ImageIO.write(image, "png", out);
    out.close();
}

public void render(GCModel model, String chartFilePath) throws IOException {
    GCPreferences gcPreferences = new GCPreferences();
    gcPreferences.load();
    final ModelChartImpl pane = new ModelChartImpl();
    pane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    pane.setModel(model, gcPreferences);
    pane.setFootprint(model.getFootprint());
    pane.setMaxPause(model.getPause().getMax());
    pane.setRunningTime(model.getRunningTime());
    Dimension d = new Dimension(gcPreferences.getWindowWidth(), gcPreferences.getWindowHeight());
    pane.setSize(d);
    pane.addNotify();
    pane.validate();
    pane.autoSetScaleFactor();
    final BufferedImage image = new BufferedImage(d.width, d.height, BufferedImage.TYPE_INT_RGB);
    final Graphics2D graphics = image.createGraphics();
    graphics.setBackground(Color.WHITE);
    graphics.clearRect(0, 0, image.getWidth(), image.getHeight());
    pane.paint(graphics);
    ImageIO.write(image, "png", new File(chartFilePath));
}

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    if (imageWritten) {
        try {
            BufferedImage img2;
            img2 = ImageIO.read(new ByteArrayInputStream(compressed));
            g.drawImage(img2, 0, 0, null);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

public static Image getImage(String name) {
    URL url = Icon.class.getResource(name);
    if (url != null) {
        try {
            return ImageIO.read(url);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    } else {
        throw new IllegalArgumentException("Icon '" + name + "' does not exist.");
    }
}

static void drawImage() throws Exception {
    URL url = VisualTest.class.getClassLoader().getResource("duke.gif");
    final BufferedImage image = ImageIO.read(url);
    paint(new Painter() {

        @Override
        public void paint(Graphics2D g2d) {
            g2d.drawImage(image, 200, 400, 20, 40, 5, 20, 200, 400, null, null);
        }
    });
}

@Override
public Background read(File path, ResourceTreeEntry entry, DeferredReferenceCreatorNotifier drcn) throws IOException {
    File imageFile = new File(path, baseFilename(entry) + ".png");
    Background background = new BackgroundXmlFormat().read(getXmlFile(path, entry), drcn);
    background.setName(entry.name);
    if (imageFile.isFile()) {
        BufferedImage bg = ImageIO.read(imageFile);
        background.setBackgroundImage(bg);
    }
    return background;
}

protected synchronized BufferedImage get(Tile tile) {
    String name = TileServer.getTileName(tile);
    File file = new File(store, name);
    if (!file.exists())
        return null;
    BufferedImage image;
    try {
        image = ImageIO.read(file);
    } catch (IOException e) {
        image = null;
        e.printStackTrace();
    }
    return image;
}

@Override
public void generatePngFile() throws IOException {
    File midPngFile = File.createTempFile("html_to_png_ff3_mid", ".png");
    midPngFile.deleteOnExit();
    ProcessBuilder pb = new ProcessBuilder("/usr/bin/gnome-web-photo", htmlFile.getAbsolutePath(), midPngFile.getAbsolutePath());
    Process p = pb.start();
    try {
        p.waitFor();
    } catch (InterruptedException e) {
        p.destroy();
        throw new IOException(e);
    }
    BufferedImage midImage = ImageIO.read(midPngFile);
    BufferedImage finalImage = (new ImageProcessor()).autocropImage(midImage);
    ImageIO.write(finalImage, "png", pngFile);
    midPngFile.delete();
}

public BufferedImage readImage(InputStream imageData) throws IOException {
    ImageInputStream stream = ImageIO.createImageInputStream(imageData);
    for (Iterator<ImageReader> iterator = ImageIO.getImageReaders(stream); iterator.hasNext(); ) {
        ImageReader imageReader = iterator.next();
        imageReader.setInput(stream);
        try {
            BufferedImage image = imageReader.read(0);
            stream.close();
            return image;
        } catch (IIOException e) {
            LOGGER.error("Reading stream failed, attempting to read with next JPEG reader.", e);
        }
    }
    return null;
}

private ImageIcon createIcon(String uri) {
    URL uriToLoad = null;
    ImageIcon icon = null;
    try {
        if (uri.startsWith("classpath:")) {
            uriToLoad = getClass().getClassLoader().getResource(uri.substring("classpath:".length()));
        } else {
            uriToLoad = new URL(uri);
        }
        final BufferedImage bufferedImage = ImageIO.read(uriToLoad);
        if (bufferedImage != null) {
            icon = new ImageIcon(bufferedImage);
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
    if (icon != null) {
        iconCache.put(uri, icon);
    }
    return icon;
}

@Override
protected JComponent createViewPanel() {
    final String png = myCell.getBase64String();
    final JBLabel label = new JBLabel();
    if (!StringUtil.isEmptyOrSpaces(png)) {
        try {
            byte[] btDataFile = new BASE64Decoder().decodeBuffer(png);
            BufferedImage image = ImageIO.read(new ByteArrayInputStream(btDataFile));
            label.setIcon(new ImageIcon(image));
        } catch (Exception e) {
            LOG.error("Couldn't parse image. " + e.getMessage());
        }
    }
    label.setBackground(IpnbEditorUtil.getBackground());
    label.setOpaque(true);
    return label;
}

@OnMessage
public void onMessage(String message, Session session) {
    try {
        OutputStream sendStream = session.getBasicRemote().getSendStream();
        switch(message) {
            case "screenshot":
                CountDownLatch latch = new CountDownLatch(1);
                ScreenCapture screenCapture = new ScreenCapture( img -> {
                    image = img;
                    latch.countDown();
                });
                screenCapture.setVisible(true);
                latch.await();
                ImageWriter writer = ImageIO.getImageWritersByFormatName(Main.SCREEN_SHOT_FILE_FORMAT).next();
                ImageWriteParam imgParam = writer.getDefaultWriteParam();
                imgParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                //Highest quality
                imgParam.setCompressionQuality(1.0F);
                ImageOutputStream ios = ImageIO.createImageOutputStream(sendStream);
                writer.setOutput(ios);
                IIOImage iioImage = new IIOImage(image, null, null);
                writer.write(null, iioImage, imgParam);
                sendStream.close();
                break;
        }
    } catch (IOExceptionInterruptedException |  e1) {
        e1.printStackTrace();
    }
}

public void testScalePng() throws Exception {
    BufferedImage img = ImageIO.read(getClass().getResourceAsStream("issue18.png"));
    int width = img.getWidth() / 2;
    int height = img.getHeight() / 2;
    ResampleOp resampleOp = new ResampleOp(width, height);
    resampleOp.setUnsharpenMask(AdvancedResizeOp.UnsharpenMask.None);
    BufferedImage rescaledImage = resampleOp.filter(img, null);
    ImageIO.write(rescaledImage, "png", new File("Issue18_rescaled.png"));
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR);
    System.out.println("src " + rescaledImage.getColorModel().getTransferType());
    System.out.println("dest " + bi.getColorModel().getTransferType());
    ColorConvertOp colorConv = new ColorConvertOp(rescaledImage.getColorModel().getColorSpace(), bi.getColorModel().getColorSpace(), null);
    colorConv.filter(rescaledImage, bi);
    ImageIO.write(bi, "jpg", new File("Issue18_rescaled.jpg"));
}

@Test
@Ignore
public void testImage() throws IOException {
    String path = TestUtil.path + "/image";
    String path_temp = TestUtil.path + "/temp/image";
    String file = path + "1.jpg";
    String file_temp = path_temp + "1.jpg";
    BufferedImage bufferedImage = ImageIO.read(new File(file));
    BufferedImage bufferedImage1 = zoomInImage(bufferedImage, 50);
    FileOutputStream outputStream = new FileOutputStream(file_temp);
    ImageIO.write(bufferedImage1, "jpg", outputStream);
}

@Override
public void render(JPanel dialogPanel, byte[] file) {
    try {
        InputStream in = new ByteArrayInputStream(file);
        BufferedImage imageRaw = ImageIO.read(in);
        JPanel scrollPane = new AutoResizeImagePanel(imageRaw);
        dialogPanel.add(scrollPane);
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

static ImageIcon createImageIcon(String iconName) {
    ImageIcon result = null;
    String fullIconPath = "/viewer/icons/" + iconName + ".png";
    try {
        Image image = ImageIO.read(ViewerUtil.class.getResourceAsStream(fullIconPath));
        result = new ImageIcon(image);
    } catch (Exception e) {
        log.warning("Icon \'" + fullIconPath + "\' not found");
    }
    return result;
}

@Override
public void run() {
    for (int i = 0; i < 100; i++) {
        try {
            ColorProcessor processor = new ColorProcessor(ImageIO.read(new File(MyRGBThreadTest.class.getResource("/test.jpg").toURI())));
            Histogram histogram = new Histogram();
            histogram.type = Histogram.TYPE.RGB;
            histogram.bins = 128;
            histogram.run(processor);
            List<double[]> features = histogram.getFeatures();
        // do nothing
        } catch (IOExceptionURISyntaxException |  e) {
            e.printStackTrace();
        }
    }
}

public void onVideoPicture(IVideoPictureEvent evt) {
    if (evt.getMediaData().isKeyFrame()) {
        try {
            if (evt.getImage() != null) {
                File file = new File("E:\\TEMP\\images\\keyframe-" + System.currentTimeMillis() + ".jpg");
                ImageIO.write(evt.getImage(), "jpg", file);
            } else {
                System.out.println("Dropping keyframe");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

private void initComponents() {
    JPanel mainPanel = new JPanel(new BorderLayout(0, 0));
    JPicturePanel pp = new JPicturePanel();
    try {
        pp.setImage(ImageIO.read(getClass().getResource("/com/jds/jn/resources/images/logo.png")));
    } catch (IOException e) {
        e.printStackTrace();
    }
    pp.setPreferredSize(pp.getImageSize());
    mainPanel.add(pp, BorderLayout.CENTER);
    setContentPane(mainPanel);
}

/*
	 * We need to implement this method that returns the resource as a stream.
	 */
@Override
public InputStream getStream() {
    /* Create an image and draw something on it. */
    BufferedImage image = new BufferedImage(750, 500, BufferedImage.TYPE_INT_RGB);
    Graphics drawable = image.getGraphics();
    drawable.setColor(Color.lightGray);
    drawable.fillRect(0, 0, 750, 500);
    drawable.setColor(Color.yellow);
    drawable.fillOval(150, 25, 450, 450);
    drawable.setColor(Color.black);
    drawable.drawString("drawn=" + new Date().toString(), 280, 240);
    try {
        /* Write the image to a buffer. */
        this.imagebuffer = new ByteArrayOutputStream();
        ImageIO.write(image, "png", this.imagebuffer);
        /* Return a stream from the buffer. */
        return new ByteArrayInputStream(this.imagebuffer.toByteArray());
    } catch (IOException e) {
        return null;
    }
}

public static byte[] getPngIcon(File file) {
    String key = getMapKey(file);
    byte[] ret = map.get(key);
    if (ret == null) {
        try {
            sun.awt.shell.ShellFolder sf = sun.awt.shell.ShellFolder.getShellFolder(file);
            ImageIcon icon = new ImageIcon(sf.getIcon(true));
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ImageIO.write((BufferedImage) icon.getImage(), "PNG", bos);
            ret = bos.toByteArray();
            map.put(key, ret);
        } catch (IOException e) {
            System.out.println(e);
        }
    }
    return ret;
}

public static void resizeImage(String entree, String sortie, String format) throws IOException {
    //======================================
    BufferedImage bufferedImage = ImageIO.read(new File(entree));
    int max = 480;
    if (bufferedImage.getHeight() > max || bufferedImage.getWidth() > max)
        bufferedImage = Scalr.resize(bufferedImage, max);
    File iwriter = new File(sortie);
    ImageIO.write(bufferedImage, format, iwriter);
}

public static void main(String[] args) throws Exception {
    File file = new File(System.getProperty("user.dir") + "/dev/li/code/1.gif");
    BufferedImage in = ImageIO.read(file);
    int width = in.getWidth();
    int height = in.getHeight();
    BufferedImage out = new BufferedImage(width, height, in.getType());
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < height; y++) {
            int rgb = in.getRGB(x, y);
            out.setRGB(x, y, 0x00FF0000);
        }
    }
    ImageIO.write(out, "PNG", new File("C:/Users/li/Desktop/out.png"));
}

public static void main(String[] argv) {
    try {
        PrintWriter writer = new PrintWriter("correct.out", "UTF-8");
        for (int z = 1; z <= 12; z++) {
            BufferedImage image = ImageIO.read(new File(z + ".jpg"));
            int dimension = 105 * 105;
            int width = image.getWidth();
            int height = image.getHeight();
            int[][] result = new int[height][width];
            writer.print(z);
            for (int row = 0; row < height; row++) {
                for (int col = 0; col < width; col++) {
                    result[row][col] = image.getRGB(col, row);
                    if (result[row][col] < -10) {
                        writer.print(" " + (row * 105 + col + 1) + ":" + 1);
                        System.out.println("[" + row + "," + col + "]" + result[row][col]);
                    }
                }
            }
            writer.println();
        }
        writer.close();
    } catch (Exception e) {
    }
}

public void render(MapView map, MapCanvas canvas) {
    map.setRate(128);
    map.setPrintOrder(MapPrintOrder.Sequential);
    if ((cont++ % 60) != 0)
        return;
    inj++;
    BufferedImage img;
    try {
        img = ImageIO.read(new File("c:/nyancat/acertaincat.gif Frame 0 " + (((inj) % 12) + 1) + ".png"));
    } catch (IOException e) {
        e.printStackTrace();
        return;
    }
    map.getDrawer().drawImage(img);
    return;
}

public Image getBackground() {
    if (background == null) {
        try {
            background = ImageIO.read(SimpleTheme.class.getResourceAsStream("/" + api.getConfig().getString("theme.simple.background"))).getScaledInstance(32, 32, 16);
        } catch (final IOException e) {
            e.printStackTrace();
        }
    }
    return background;
}

public void run() {
    HttpURLConnection httpurlconnection = null;
    try {
        URL url = new URL(location);
        httpurlconnection = (HttpURLConnection) url.openConnection();
        httpurlconnection.setDoInput(true);
        httpurlconnection.setDoOutput(false);
        httpurlconnection.connect();
        if (httpurlconnection.getResponseCode() / 100 == 4) {
            return;
        }
        if (buffer == null) {
            imageData.image = ImageIO.read(httpurlconnection.getInputStream());
        } else {
            imageData.image = buffer.parseUserSkin(ImageIO.read(httpurlconnection.getInputStream()));
        }
    } catch (Exception exception) {
        exception.printStackTrace();
    } finally {
        httpurlconnection.disconnect();
    }
}

protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    BufferedImage img = null;
    try {
        img = ImageIO.read(new File("resources/metrobotics-large-v5.gif"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    g.drawImage(img, 10, 0, 290, 50, this);
    g.setFont(new Font("SansSerif", Font.BOLD, 22));
    g.drawString("Human Robot Interface", 25, 90);
}

public static BufferedImage getImage(String imageName) {
    logger.info("GetImage.getImage:begin to get default image:" + imageName);
    BufferedImage image = null;
    try {
        String urlStr = ResourcePath.getHeadDefaultPath() + imageName;
        logger.info("GetImage:imageUrl:" + urlStr);
        //			URL url = new URL(urlStr);  
        //			HttpURLConnection connection2 = (HttpURLConnection) url.openConnection();  
        //			String cookieVal=null;
        //			String key=null;
        //			String cookies=null;
        //			for (int i = 1; (key = connection2.getHeaderFieldKey(i)) != null; i++ ) {
        //		         if (key.equalsIgnoreCase("set-cookie")) {
        //		          cookieVal = connection2.getHeaderField(i);
        //		          cookieVal = cookieVal.substring(0, cookieVal.indexOf(";"));
        //		          cookies = cookies+cookieVal+";";
        //		         }
        //		      }
        //			connection2.connect();
        //			image = ImageIO.read(connection2.getInputStream()); 
        image = ImageIO.read(new File(urlStr));
        logger.info("GetImage.getImage:get default image:" + imageName + " success!");
        return image;
    } catch (Exception e) {
        logger.error("GetImage.getImage:get default image:" + imageName + " fail!");
        logger.error(e.getStackTrace());
        return null;
    }
}

public void run() {
    HttpURLConnection httpurlconnection = null;
    try {
        URL url = new URL(this.location);
        httpurlconnection = (HttpURLConnection) url.openConnection();
        httpurlconnection.setDoInput(true);
        httpurlconnection.setDoOutput(false);
        httpurlconnection.connect();
        if (httpurlconnection.getResponseCode() / 100 == 4) {
            return;
        }
        if (this.buffer == null) {
            this.imageData.image = ImageIO.read(httpurlconnection.getInputStream());
        } else {
            this.imageData.image = this.buffer.parseUserSkin(ImageIO.read(httpurlconnection.getInputStream()));
        }
    } catch (Exception exception) {
        exception.printStackTrace();
    } finally {
        httpurlconnection.disconnect();
    }
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    response.setDateHeader("Expires", 0L);
    response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
    response.addHeader("Cache-Control", "post-check=0, pre-check=0");
    response.setHeader("Pragma", "no-cache");
    response.setContentType("image/jpeg");
    String id = request.getRequestedSessionId();
    BufferedImage bi = JCaptcha.captchaService.getImageChallengeForID(id);
    ServletOutputStream out = response.getOutputStream();
    ImageIO.write(bi, "jpg", out);
    try {
        out.flush();
    } finally {
        out.close();
    }
}

public void resizeImageFile(File inFile, File outFile, int maxWidth, int maxHeight, String format) throws IOException {
    BufferedImage img = ImageIO.read(inFile);
    int width = img.getWidth();
    int height = img.getHeight();
    double factor = 1.0;
    if (width > maxWidth) {
        factor = (double) width / (double) maxWidth;
    } else if (height > maxHeight) {
        factor = min(factor, (double) height / (double) maxHeight);
    }
    width *= factor;
    height *= factor;
    BufferedImage result = new BufferedImage(img.getType(), width, height);
    Graphics2D graphics = result.createGraphics();
    AffineTransform affineTransform = AffineTransform.getScaleInstance(factor, factor);
    graphics.drawRenderedImage(img, affineTransform);
    ImageIO.write(img, format, outFile);
}

public byte[] formatImage(BufferedImage bi) {
    BufferedImage reducedImage = null;
    if (bi.getColorModel().hasAlpha()) {
        reducedImage = ColorReducer.reduce32(bi, 256);
    } else {
        reducedImage = ColorReducer.reduce24(bi, 256);
    }
    try {
        ByteArrayOutputStream byo = new ByteArrayOutputStream();
        ImageIO.write(reducedImage, getFormatName(), byo);
        return byo.toByteArray();
    } catch (java.io.IOException e) {
        Debug.error("ImageIOFormatter caught IOException formatting image!");
        return new byte[0];
    }
}

@Test
@Ignore
public void testImage() throws IOException {
    String path = TestUtil.path + "/image";
    String path_temp = TestUtil.path + "/temp/image";
    String file = path + "1.jpg";
    String file_temp = path_temp + "1.jpg";
    BufferedImage bufferedImage = ImageIO.read(new File(file));
    BufferedImage bufferedImage1 = zoomInImage(bufferedImage, 50);
    FileOutputStream outputStream = new FileOutputStream(file_temp);
    ImageIO.write(bufferedImage1, "jpg", outputStream);
}

@Override
public BufferedImage loadImage(double south, double west, double north, double east) throws Exception {
    File file = new File(path, new StringBuilder().append("south=").append(String.valueOf(south)).append("&west=").append(String.valueOf(west)).append("&north=").append(String.valueOf(north)).append("&east=").append(String.valueOf(east)).append(".png").toString());
    if (file.exists()) {
        return ImageIO.read(file);
    }
    BufferedImage image = cached.loadImage(south, west, north, east);
    ImageIO.write(image, "png", file);
    return image;
}

@Override
public BufferedImage getOverviewImage(int treeId, String layoutId) {
    BufferedImage image = null;
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
        connection = pool.getConnection();
        String sql = "Select * from overview_images where tree_id=?";
        statement = connection.prepareCall(sql);
        statement.setInt(1, treeId);
        rs = statement.executeQuery();
        if (rs.next()) {
            String path = rs.getString("image_path");
            image = ImageIO.read(new File(path));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        ConnectionUtil.close(connection);
        ConnectionUtil.close(statement);
        ConnectionUtil.close(rs);
    }
    return image;
}

public static void main(String[] args) {
    FileInputStream fileInputStream = null;
    ImageInputStream imageInputStream = null;
    try {
        fileInputStream = new FileInputStream("/home/yumingzhe/a.jpg");
        Iterator iterator = ImageIO.getImageReadersByFormatName("jpg");
        ImageReader imageReader = (ImageReader) iterator.next();
        imageInputStream = ImageIO.createImageInputStream(fileInputStream);
        imageReader.setInput(imageInputStream, true);
        ImageReadParam param = imageReader.getDefaultReadParam();
        Rectangle rect = new Rectangle(0, 0, 100, 100);
        param.setSourceRegion(rect);
        BufferedImage bi = imageReader.read(0, param);
        ImageIO.write(bi, "jpg", new File("/home/yumingzhe/b.jpg"));
        imageInputStream.close();
        fileInputStream.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void write(HttpRequest request, HttpResponse response, String type, RenderedImage content) {
    OutputStream outputStream = null;
    try {
        outputStream = response.getOutputStream();
        ImageIO.write(content, type, outputStream);
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new HttpException(HttpMessage.INTERNAL_SERVER_ERROR);
    }
}

@Test
public void testImageWithSerializedResource() {
    BufferedImage image = null;
    URL imageURL = buildUrl(contextPath, imageOne.getAttribute("src"));
    try {
        image = ImageIO.read(imageURL);
    } catch (IOException ex) {
        fail("Could not download image from URL " + imageURL.getPath());
    }
    assertEquals(image.getHeight(), 120, "Height of the image");
    assertEquals(image.getWidth(), 300, "Width of the image");
}

public Image loadFromBytes(byte[] data, Set<String> errors) throws ContentManagerException {
    ByteArrayInputStream is = new ByteArrayInputStream(data);
    Image image = null;
    try {
        // create an awt image and wait 'till it's fully loaded
        image = ImageIO.read(is);
        ImageWaiter.wait(image);
    } catch (Throwable e) {
        if (errors != null) {
            errors.add(ExceptionUtils.getExceptionStackTrace(e));
        }
        image = null;
    }
    return image;
}

public void testPut01() throws Exception {
    // assertTrue(true);
    RomaClientFactory factory = RomaClientFactory.getInstance();
    RomaClient client = factory.newRomaClient(new Properties());
    BufferedImageWrapper appender = new BufferedImageWrapper(client);
    client.open(Node.create(NODE_ID));
    appender.setFormat("jpg");
    String filePathName = "src/test/resources/";
    String testPathName = "target/";
    for (int i = 1; i <= 35; ++i) {
        File imgFile = new File(filePathName + i + ".jpg");
        BufferedImage img = ImageIO.read(imgFile);
        assertTrue(appender.put(KEY_PREFIX + "_img_" + i, img));
        BufferedImage newImg = appender.get(KEY_PREFIX + "_img_" + i);
        // assertEquals(img.hashCode(), newImg.hashCode());
        ImageIO.write(newImg, "jpg", new File(testPathName + "new_" + i + ".jpg"));
    }
    client.close();
}

@Override
public BufferedImage getScreenshot(WebDriver wd) {
    ByteArrayInputStream imageArrayStream = null;
    TakesScreenshot takesScreenshot;
    try {
        takesScreenshot = (TakesScreenshot) wd;
    } catch (ClassCastException ignored) {
        takesScreenshot = (TakesScreenshot) new Augmenter().augment(wd);
    }
    try {
        imageArrayStream = new ByteArrayInputStream(takesScreenshot.getScreenshotAs(OutputType.BYTES));
        return ImageIO.read(imageArrayStream);
    } catch (IOException e) {
        throw new ImageReadException("Can not parse screenshot data", e);
    } finally {
        IOUtils.closeQuietly(imageArrayStream);
    }
}