public void drawImage(BufferedImage bImg,
                      BufferedImageOp op,
                      int x,
                      int y)  {

    if (bImg == null) {
        return;
    }

    try {
        imagepipe.transformImage(this, bImg, op, x, y);
    } catch (InvalidPipeException e) {
        try {
            revalidateAll();
            imagepipe.transformImage(this, bImg, op, x, y);
        } catch (InvalidPipeException e2) {
            // Still catching the exception; we are not yet ready to
            // validate the surfaceData correctly.  Fail for now and
            // try again next time around.
        }
    } finally {
        surfaceData.markDirty();
    }
}
 

@Override
public BufferedImage doTransform(BufferedImage src, BufferedImage dest) {
    if (filter == null) {
        filter = new PolarTilesFilter();
    }

    filter.setRelCenter(center.getRelativeX(), center.getRelativeY());
    filter.setEdgeAction(edgeAction.getValue());
    filter.setInterpolation(interpolation.getValue());
    filter.setRotateResult((float) rotateImage.getValueInIntuitiveRadians());
    filter.setZoom(zoom.getPercentageValF());
    filter.setT(rotateEffect.getPercentageValF());
    filter.setNumADivisions(numAngDivisions.getValue());
    filter.setNumRDivisions(numRadDivisions.getValue());
    filter.setCurvature(curvature.getValueAsDouble());
    filter.setRandomness(randomness.getPercentageValF());

    dest = filter.filter(src, dest);
    return dest;
}
 

private void assertImageMatches(CumulativeMatcher matcher) {
	// We only expect ballon to be returned
	final PriorityQueue<Result<BufferedImage>> results = matcher.getMatchingImages(ballon);

	assertAll("Ballon", () -> {
		assertEquals(1, results.size());
	}, () -> {
		assertEquals(ballon, results.peek().value);
	});

	final PriorityQueue<Result<BufferedImage>> results1 = matcher.getMatchingImages(highQuality);

	assertAll("Matches", () -> {
		assertEquals(4, results1.size());
	}, () -> {
		assertFalse(results1.stream().anyMatch(result -> result.value.equals(ballon)));
	});
}
 

private void calcConstants(int width, int height) {
    if ((width >= MIN_WIDTH) && (height >= MIN_HEIGHT)) {
        double oldIntervalWidth = xHighLimit - xLowLimit;
        double oldIntervalHeight = yHighLimit - yLowLimit;
        double newIntervalWidth =
                width * oldIntervalWidth / oldComponentWidth;
        double newIntervalHeight =
                height * oldIntervalHeight / oldComponentHeight;
        double xDiff = newIntervalWidth - oldIntervalWidth;
        double yDiff = newIntervalHeight - oldIntervalHeight;
        xLowLimit -= xDiff / 2;
        xHighLimit += xDiff / 2;
        yLowLimit -= yDiff / 2;
        yHighLimit += yDiff / 2;
        buffer = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        oldComponentWidth = width;
        oldComponentHeight = height;
        setCenter(calcCenter());
    }
}
 

public ImageGenerator(int _width, int _height, Color bgColor)
{
      width = _width;
      height = _height;
      bi = new BufferedImage(
          width,
          height,
          BufferedImage.TYPE_INT_ARGB);
      Graphics gr = bi.getGraphics();
      if(null==bgColor){
          bgColor = Color.WHITE;
      }
      gr.setColor(bgColor);
      gr.fillRect(0, 0, width, height);
      paint(gr);
      gr.dispose();
}
 

@Override
public void init(GLAutoDrawable drawable) {
    final GL2 gl = drawable.getGL().getGL2();
    gl.glShadeModel(GL2.GL_SMOOTH);
    gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    gl.glClearDepth(1.0f);
    gl.glEnable(GL2.GL_DEPTH_TEST);
    gl.glDepthFunc(GL2.GL_LEQUAL);
    gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
    gl.glEnable(GL2.GL_TEXTURE_2D);
    
    try {
        File im = new File("D:\\Temp\\image\\lenna.jpg ");
        //File im = new File("D:\\Temp\\Map\\GLOBALeb3colshade.jpg");
        BufferedImage image = ImageIO.read(im);
        Texture t = AWTTextureIO.newTexture(gl.getGLProfile(), image, true);
        //Texture t = TextureIO.newTexture(im, true);
        texture = t.getTextureObject(gl);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

@Override
public BufferedImage doTransform(BufferedImage src, BufferedImage dest) {
    if (amount.isZero()) {
        return src;
    }
    
    if(filter == null) {
        filter = new SwimFilter(NAME);
    }

    filter.setAmount(amount.getValueAsFloat());
    filter.setScale(scale.getValueAsFloat());
    filter.setStretch((float) Math.pow(10.0, stretch.getValueAsDouble() / 100.0));
    filter.setTime(time.getPercentageValF());
    filter.setAngle((float) (angle.getValueInRadians() + Math.PI / 2.0));
    filter.setEdgeAction(edgeAction.getValue());
    filter.setInterpolation(interpolation.getValue());

    dest = filter.filter(src, dest);
    return dest;
}
 

protected static SurfaceData convertFrom(Blit ob, SurfaceData srcData,
                                         int srcX, int srcY, int w, int h,
                                         SurfaceData dstData, int type)
{
    if (dstData != null) {
        Rectangle r = dstData.getBounds();
        if (w > r.width || h > r.height) {
            dstData = null;
        }
    }
    if (dstData == null) {
        BufferedImage dstBI = new BufferedImage(w, h, type);
        dstData = BufImgSurfaceData.createData(dstBI);
    }
    ob.Blit(srcData, dstData, AlphaComposite.Src, null,
            srcX, srcY, 0, 0, w, h);
    return dstData;
}
 

/**
 * 指定されたリスト内の最後の画像の高さ、スクロール量、ボーダー幅から<br>
 * トリム量を計算し、縦の重複をトリムします。
 *
 * @param images 対象の画像
 * @param lastScrollAmount 最後のスクロール量
 * @param el 撮影対象の要素
 * @param currentScale 表示領域とスクリーンショットのサイズ比
 */
protected void trimBottomImage(List<BufferedImage> images, long lastScrollAmount, PtlWebElement el,
		double currentScale) {
	LOG.trace("(trimBottomImage) lastScrollAmount: {}, el: {}, currentScroll: {}", lastScrollAmount, el,
			currentScale);

	int size = images.size();
	// 画像が1枚しかないときは何もしない
	if (size <= 1) {
		return;
	}

	BufferedImage lastImage = images.get(size - 1);
	int trimTop = calcTrimTop(lastImage.getHeight(), lastScrollAmount, el, currentScale);
	LOG.trace("(trimBottomImage) trim: {}", trimTop);

	if (trimTop > 0 && trimTop < lastImage.getHeight()) {
		images.set(size - 1, ImageUtils.trim(lastImage, trimTop, 0, 0, 0));
	}
}
 

@Override
public double getCalibrationFactor()
{
    final BufferedImage buf = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB);
    final Graphics2D gc = buf.createGraphics();
    gc.setFont(font);
    final FontMetrics metrics = gc.getFontMetrics();
    text_width = metrics.stringWidth(FontCalibration.TEXT);
    text_height = metrics.getHeight();
    gc.dispose();

    logger.log(Level.FINE,
               "Font calibration measure: " + text_width + " x " + text_height);
    final double factor = FontCalibration.PIXEL_WIDTH / text_width;
    logger.log(Level.CONFIG, "AWT font calibration factor: {0}", factor);
    return factor;
}
 

private static boolean isSameColors(BufferedImage src, BufferedImage dst) {
    Object dstPixel = dst.getRaster().getDataElements(width/2, height/2, null);
    Object srcPixel = src.getRaster().getDataElements(width/2, height/2, null);

    // take into account the rounding error
    if ( Math.abs(src.getColorModel().getRed(srcPixel) -  dst.getColorModel().getRed(dstPixel)) > 1
         || Math.abs(src.getColorModel().getGreen(srcPixel) - dst.getColorModel().getGreen(dstPixel)) > 1
         || Math.abs(src.getColorModel().getBlue(srcPixel) - dst.getColorModel().getBlue(dstPixel)) > 1) {
        showPixel(src, width/2, height/2);
        showPixel(dst, width/2, height/2);

        throw new RuntimeException( "Colors are different: "
                                    + Integer.toHexString(src.getColorModel().getRGB(srcPixel))
                                    + " and "
                                    + Integer.toHexString(dst.getColorModel().getRGB(dstPixel)));
    }
    return true;
}
 

/**
 * Returns the SurfaceManager object contained within the given Image.
 */
public static SurfaceManager getManager(Image img) {
    SurfaceManager sMgr = imgaccessor.getSurfaceManager(img);
    if (sMgr == null) {
        /*
         * In practice only a BufferedImage will get here.
         */
        try {
            BufferedImage bi = (BufferedImage) img;
            sMgr = new BufImgSurfaceManager(bi);
            setManager(bi, sMgr);
        } catch (ClassCastException e) {
            throw new IllegalArgumentException("Invalid Image variant");
        }
    }
    return sMgr;
}
 

public static void writeGifImageFile(BufferedImage image,
        ImageAttributes attributes, String outFile) {
    try {
        ImageWriter writer = getWriter();
        ImageWriteParam param = getPara(attributes, writer);
        IIOMetadata metaData = getWriterMeta(attributes, image, writer, param);

        try ( ImageOutputStream out = ImageIO.createImageOutputStream(new File(outFile))) {
            writer.setOutput(out);
            writer.write(metaData, new IIOImage(image, null, metaData), param);
            out.flush();
        }
        writer.dispose();

    } catch (Exception e) {
        logger.error(e.toString());
    }
}
 

@Override
public void makeNoise(BufferedImage image, float factorOne, float factorTwo, float factorThree, float factorFour) {

    int width = image.getWidth();
    int height = image.getHeight();
    Graphics2D graph = (Graphics2D)image.getGraphics();
    graph.setRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
    graph.setStroke(new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
    Random random = new Random();
    int noiseLineNum = random.nextInt(3);
    if(noiseLineNum == 0){
        noiseLineNum = 1;
    }
    for (int i = 0; i < noiseLineNum; i++){
        graph.setColor(KaptchaColor.getColor());
        graph.drawLine(random.nextInt(width), random.nextInt(height), 10 + random.nextInt(20), 10 + random.nextInt(20));
    }

    graph.dispose();
}
 

void testStrikthrough() {
    System.out.println("  testStrikthrough()");

    final BufferedImage img1 = createImage();
    drawText(img1.getGraphics(), false, true, false);
    final Rectangle out1 = getPixelsOutline(img1);
    System.out.println("   Striked: " + out1);

    final BufferedImage img2 = createImage();
    drawText(img2.getGraphics(), false, false, false);
    final Rectangle out2 = getPixelsOutline(img2);
    System.out.println("   Normal: " + out2);

    final BufferedImage img3 = subImages(img1, img2);
    final Rectangle out3 = getPixelsOutline(img3);
    System.out.println("   Sub: " + out3);

    // strikethrough is not too thick
    assertTrue(out3.getHeight() <= 2);
    // not too wide
    assertTrue(out3.getWidth() * 0.8 < out2.getWidth());
    // not too low
    assertTrue(out3.getY() - (out1.getY() + out2.getHeight() - 1) < 0);
    // not too high
    assertTrue(out3.getY() - out1.getY() > 1);
}
 

public static void main(String[] argv) throws Exception {
    BufferedImage im = getWhiteImage(30, 30);
    Graphics2D g2 = (Graphics2D)im.getGraphics();
    g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
    g2.setRenderingHint(KEY_STROKE_CONTROL, VALUE_STROKE_PURE);
    g2.setStroke(new BasicStroke(10, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
    g2.setBackground(Color.white);
    g2.setColor(Color.black);

    Path2D p = getPath(0, 0, 20);
    g2.draw(p);

    if (!(new Color(im.getRGB(20, 19))).equals(Color.black)) {
        throw new Exception("This pixel should be black");
    }
}
 

/**
 * Renders contours to the passed image.
 *
 * @param destinationImage Image must be this.scale times larger than the
 * grid.
 * @param grid Grid with elevation values.
 * @param slopeGrid Grid with slope values.
 * @param progress Progress indicator. Not used when scale is 1.
 */
public void renderToImage(BufferedImage destinationImage, Grid grid, Grid slopeGrid, ProgressIndicator progress) {
    if (destinationImage == null) {
        throw new IllegalArgumentException();
    }
    this.image = destinationImage;
    this.progress = progress;
    this.imageBuffer = ((DataBufferInt) (image.getRaster().getDataBuffer())).getData();
    this.smoothGrid = new LowPassOperator(aspectGaussBlur).operate(grid);
    super.operate(grid, slopeGrid);
}
 

public static void computeRegions(ImageReadParam param,
                                  int srcWidth,
                                  int srcHeight,
                                  BufferedImage image,
                                  Rectangle srcRegion,
                                  Rectangle destRegion) {
    ImageReader.computeRegions(param,
                               srcWidth,
                               srcHeight,
                               image,
                               srcRegion,
                               destRegion);
}
 

public static void main(final String[] args) {
    for (final AffineTransform atfm : TRANSFORMS) {
        for (final int viType : TRANSPARENCIES) {
            for (final int biType : TYPES) {
                final BufferedImage bi = makeUnmanagedBI(biType);
                final VolatileImage vi = makeVI(viType);
                final long time = test(bi, vi, atfm) / 1000000000;
                if (time > 1) {
                    throw new RuntimeException(String.format(
                            "drawImage is slow: %d seconds", time));
                }
            }
        }
    }
}
 

public void testReadingDoesNotCrash() throws IOException {
  InputStream resource = WmfReadingTest.class.getResourceAsStream( "anim0002.wmf" );
  assertNotNull( resource );
  WmfFile wmfFile = new WmfFile( resource, 800, 600 );
  BufferedImage bi = new BufferedImage( 800, 600, BufferedImage.TYPE_4BYTE_ABGR );
  Graphics2D graphics = bi.createGraphics();
  wmfFile.draw( graphics, new Rectangle2D.Double( 0, 0, 800, 600 ) );
  graphics.dispose();
}
 

private static void test(final BufferedImage gold, final BufferedImage bi)
        throws IOException {
    for (int x = 0; x < size; x++) {
        for (int y = 0; y < size; y++) {
            if (gold.getRGB(x, y) != bi.getRGB(x, y)) {
                ImageIO.write(gold, "png", new File("gold.png"));
                ImageIO.write(bi, "png", new File("image.png"));
                throw new RuntimeException("wrong color");
            }
        }
    }
}
 

private BufferedImage image2bufferedImage( Image image ) {
	if( image instanceof BufferedImage )
		return (BufferedImage) image;

	BufferedImage bufferedImage = new BufferedImage( image.getWidth( null ),
		image.getHeight( null ), BufferedImage.TYPE_INT_ARGB );
	Graphics2D g = bufferedImage.createGraphics();
	try {
		g.drawImage( image, 0, 0, null );
	} finally {
		g.dispose();
	}
	return bufferedImage;
}
 

public static Image scaleImage(Image image, int width, int height) {
    if (width == image.getWidth() && height == image.getHeight()) {
        return image;
    }
    BufferedImage source = SwingFXUtils.fromFXImage(image, null);
    BufferedImage target = mara.mybox.image.ImageManufacture.scaleImage(source, width, height);
    Image newImage = SwingFXUtils.toFXImage(target, null);
    return newImage;
}
 

/**
 * 個別に撮影したScreenshotと保存済みScreenshotの比較 => 検証失敗
 */
@Test
public void verifyScreenshot_failed() throws Exception {
	BufferedImage image = ImageIO.read(getClass().getResource("images/hifive_logo_part.png"));

	when(testResultManager.getPersister().loadTargetResults(any(PersistMetadata.class)))
			.thenReturn(createScreenshotResult(image).getTargetResults());

	expectedException.expect(AssertionError.class);
	expectedException.expectMessage(startsWith("Verified 1 errors"));

	assertionView.verifyScreenshot(screenshotResult);
	assertTrue(true);
}
 

public static byte[] scale(byte[] img, int height, int width,boolean flag,String imageType) throws Exception{
	double ratio = 0.0; //缩放比例
	InputStream inputStream = new ByteArrayInputStream(img);
	BufferedImage bi = ImageIO.read(inputStream);
	Image itemp = bi.getScaledInstance(width, height, BufferedImage.SCALE_SMOOTH);
	//计算比例
	if ((bi.getHeight() > height) || (bi.getWidth() > width)) {
		if (bi.getHeight() > bi.getWidth()) {
			ratio = (new Integer(height)).doubleValue() / bi.getHeight();
		} else {
			ratio = (new Integer(width)).doubleValue() / bi.getWidth();
		}
		AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(ratio, ratio), null);
		itemp = op.filter(bi, null);
	}
	if (flag) {//补白
		BufferedImage image = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);
		Graphics2D g = image.createGraphics();
		g.setColor(Color.white);
		g.fillRect(0, 0, width, height);
		if (width == itemp.getWidth(null)){
			g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2, itemp.getWidth(null), itemp.getHeight(null),Color.white, null);
		}else{
			g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0,itemp.getWidth(null), itemp.getHeight(null),Color.white, null);
		}
		g.dispose();
		itemp = image;
	}
	ByteArrayOutputStream outputstream = new ByteArrayOutputStream();
	ImageIO.write((BufferedImage) itemp, imageType, outputstream);
	return outputstream.toByteArray();
}
 

@Test
public void read() throws IOException {
	Resource logo = new ClassPathResource("logo.jpg", BufferedImageHttpMessageConverterTests.class);
	byte[] body = FileCopyUtils.copyToByteArray(logo.getInputStream());
	MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
	inputMessage.getHeaders().setContentType(new MediaType("image", "jpeg"));
	BufferedImage result = converter.read(BufferedImage.class, inputMessage);
	assertEquals("Invalid height", 500, result.getHeight());
	assertEquals("Invalid width", 750, result.getWidth());
}
 

/**
 * Checks that a TickUnit with a size of 0 doesn't crash.
 */
@Test
public void testRefreshTicksWithZeroTickUnit() {
    LogAxis axis = new LogAxis();
    AxisState state = new AxisState();
    BufferedImage image = new BufferedImage(200, 100,
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2 = image.createGraphics();
    Rectangle2D area = new Rectangle2D.Double(0.0, 0.0, 200, 100);
    axis.refreshTicks(g2, state, area, RectangleEdge.TOP);
}
 

public static void main(final String[] args) throws IOException {
    for (final int viType : TRANSPARENCIES) {
        for (final int biType : TYPES) {
            BufferedImage bi = makeUnmanagedBI(biType);
            fill(bi);
            test(bi, viType);
        }
    }
}
 

/**
 * 同じ画像と同じ領域を比較 => 成功
 */
@Test
public void testCompare() throws Exception {
	BufferedImage image = ImageIO.read(getClass().getResource("hifive_logo.png"));
	Rectangle rectangle = new Rectangle(0, 0, image.getWidth(), image.getHeight());
	ImageComparedResult result = new IgnoringClearPixelsImageComparator().compare(image, rectangle, image,
			rectangle);

	assertThat(result.isSucceeded(), is(true));
}
 

public static INDArray toINDArrayBGR(BufferedImage image) {
    int height = image.getHeight();
    int width = image.getWidth();
    int bands = image.getRaster().getNumBands();

    int[] pixels = new int[width * height];
    pixels = getRGB(image, 0, 0, width, height, pixels);
    int[] shape = new int[] {bands, height, width};

    INDArray ret2 = Nd4j.create(1, width * height * bands);

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int idx = y * width + x;
            int color = pixels[idx];
            int[] argb = trimRGBColor(color);
            ret2.putScalar(idx, (argb[1]) & 0xFF);
            if (bands > 1) {
                ret2.putScalar(idx + pixels.length, (argb[2]) & 0xFF);
            }
            if (bands > 2) {
                ret2.putScalar(idx + pixels.length * 2, (argb[3]) & 0xFF);
            }
        }
    }
    return Nd4j.expandDims(ret2.reshape(shape), 0);
}