/** * Loads an image from a given URL into a BufferedImage. The image is returned in the format * defined by the imageType parameter. Note that this is special cased for JPEG images where * loading is performed outside the standard media tracker, for efficiency reasons. * * @param url URL where the image file is located. * @param imageType one of the image type defined in the BufferedImage class. * @return loaded image at path or url * @see java.awt.image.BufferedImage */ public static synchronized BufferedImage loadBufferedImage(URL url, int imageType) { BufferedImage image = null; // Special handling for JPEG images to avoid extra processing if possible. if (url == null || !url.toString().toLowerCase().endsWith(".jpg")) { Image tmpImage = loadImage(url); if (tmpImage != null) { image = new BufferedImage(tmpImage.getWidth(null), tmpImage.getHeight(null), imageType); Graphics2D g = image.createGraphics(); g.drawImage(tmpImage, 0, 0, null); g.dispose(); } } else { BufferedImage tmpImage = loadBufferedJPEGImage(url); if (tmpImage != null) { if (tmpImage.getType() != imageType) { log.config("Incompatible JPEG image type: creating new buffer image"); image = new BufferedImage(tmpImage.getWidth(null), tmpImage.getHeight(null), imageType); Graphics2D g = image.createGraphics(); g.drawImage(tmpImage, 0, 0, null); g.dispose(); } else image = tmpImage; } } return image; } // loadBufferedImage
private void createImages() { int w = 16; int h = getPreferredSize().height; setTarget(new Rectangle(2, 0, 20, 18)); Graphics2D g2; open = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); g2 = open.createGraphics(); g2.setPaint(getBackground()); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.fillRect(0, 0, w, h); int[] x = {2, w / 2, 14}; int[] y = {4, 13, 4}; Polygon p = new Polygon(x, y, 3); g2.setPaint(new Color(204, 204, 204)); g2.fill(p); g2.draw(p); g2.dispose(); closed = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); g2 = closed.createGraphics(); g2.setPaint(getBackground()); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.fillRect(0, 0, w, h); x = new int[] {3, 13, 3}; y = new int[] {4, h / 2, 16}; p = new Polygon(x, y, 3); g2.setPaint(new Color(102, 102, 102)); g2.fill(p); g2.draw(p); g2.dispose(); }
// Method used to paint shadow around the panel @Override public void setBounds(int x, int y, int width, int height) { super.setBounds(x, y, width, height); int w = getWidth() - 68; int h = getHeight() - 68; int arc = 30; int shadowSize = 20; shadow = ImagesUtilities.createCompatibleTranslucentImage(w, h); Graphics2D g2 = shadow.createGraphics(); g2.setColor(Color.WHITE); g2.fillRoundRect(0, 0, w, h, arc, arc); g2.dispose(); ShadowRenderer renderer = new ShadowRenderer(shadowSize, 0.5f, Color.BLACK); shadow = renderer.createShadow(shadow); g2 = shadow.createGraphics(); // The color does not matter, red is used for debugging g2.setColor(Color.RED); g2.setComposite(AlphaComposite.Clear); g2.fillRoundRect(shadowSize, shadowSize, w, h, arc, arc); g2.dispose(); if (shadow != null) { int xOffset = (shadow.getWidth() - w) / 2; int yOffset = (shadow.getHeight() - h) / 2; g2.drawImage(shadow, x - xOffset, y - yOffset, null); } }
public BufferedImage filter(BufferedImage src, BufferedImage dst) { if (dst == null) dst = createCompatibleDestImage(src, null); BufferedImage tsrc = src; float cx = (float) src.getWidth() * centreX; float cy = (float) src.getHeight() * centreY; float imageRadius = (float) Math.sqrt(cx * cx + cy * cy); float translateX = (float) (distance * Math.cos(angle)); float translateY = (float) (distance * -Math.sin(angle)); float scale = zoom; float rotate = rotation; float maxDistance = distance + Math.abs(rotation * imageRadius) + zoom * imageRadius; int steps = log2((int) maxDistance); translateX /= maxDistance; translateY /= maxDistance; scale /= maxDistance; rotate /= maxDistance; if (steps == 0) { Graphics2D g = dst.createGraphics(); g.drawRenderedImage(src, null); g.dispose(); return dst; } BufferedImage tmp = createCompatibleDestImage(src, null); for (int i = 0; i < steps; i++) { Graphics2D g = tmp.createGraphics(); g.drawImage(tsrc, null, null); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f)); g.translate(cx + translateX, cy + translateY); g.scale( 1.0001 + scale, 1.0001 + scale); // The .0001 works round a bug on Windows where drawImage throws an // ArrayIndexOutofBoundException if (rotation != 0) g.rotate(rotate); g.translate(-cx, -cy); g.drawImage(dst, null, null); g.dispose(); BufferedImage ti = dst; dst = tmp; tmp = ti; tsrc = dst; translateX *= 2; translateY *= 2; scale *= 2; rotate *= 2; } return dst; }
@Override protected BufferedImage renderOffscreen() { BufferedImage bimage = null; if (getOrientation() == SwingConstants.HORIZONTAL) { bimage = new BufferedImage(DEFAULT_WIDTH, 10, BufferedImage.TYPE_4BYTE_ABGR); Graphics2D g2d = bimage.createGraphics(); int ncolors = colorMap.getMapSize(); double distance = colorMap.getMaximumValue() - colorMap.getMinimumValue(); double start = colorMap.getMinimumValue(); for (int i = 0; i < ncolors; i++) { ColorInterval ci = colorMap.getInterval(i); double size = ((ci.getMaximum() - ci.getMinimum()) / distance); double xpos = (ci.getMinimum() - start) / distance; Rectangle2D rect = new Rectangle2D.Double(xpos * DEFAULT_WIDTH, 0, size * DEFAULT_WIDTH, 10); float trans = (float) ci.getAlpha(); AlphaComposite comp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trans / 255f); g2d.setComposite(comp); g2d.setPaint(ci.getColor()); g2d.fill(rect); } } else { bimage = new BufferedImage(10, DEFAULT_HEIGHT, BufferedImage.TYPE_4BYTE_ABGR); int ncolors = colorMap.getMapSize(); double distance = colorMap.getMaximumValue() - colorMap.getMinimumValue(); double start = colorMap.getMinimumValue(); Graphics2D g2d = bimage.createGraphics(); for (int i = 0; i < ncolors; i++) { ColorInterval ci = colorMap.getInterval(i); double size = ((ci.getMaximum() - ci.getMinimum()) / distance); double ypos = (ci.getMinimum() - start) / distance; Rectangle2D rect = new Rectangle2D.Double(0, ypos * DEFAULT_HEIGHT, 10, size * DEFAULT_HEIGHT); float trans = (float) ci.getAlpha(); AlphaComposite comp = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trans / 255f); g2d.setComposite(comp); g2d.setPaint(ci.getColor()); g2d.fill(rect); } } cachedImage = bimage; return cachedImage; }
private synchronized void renderOutput() { switch (calibGUI.getSelectedView()) { case 0: workImage.createGraphics().drawImage(input, null, null); break; case 1: VisualizeBinaryData.renderBinary(alg.getBinary(), false, workImage); break; case 2: renderClusters(); break; default: throw new RuntimeException("Unknown mode"); } Graphics2D g2 = workImage.createGraphics(); if (foundTarget) { if (calibGUI.isShowBound()) { // Polygon2D_I32 bounds = alg.getFindBound().getBoundPolygon(); // drawBounds(g2, bounds); } if (calibGUI.isShowNumbers()) { drawNumbers(g2, alg.getCalibrationPoints(), null, 1); } calibGUI.setSuccessMessage("FOUND", true); } else { if (calibGUI.isShowBound()) { // Polygon2D_I32 bounds = alg.getFindBound().getBoundPolygon(); // drawBounds(g2, bounds); } calibGUI.setSuccessMessage("FAILED", false); } if (calibGUI.isShowPoints()) { List<Point2D_F64> candidates = alg.getCalibrationPoints(); for (Point2D_F64 c : candidates) { VisualizeFeatures.drawPoint(g2, (int) (c.x + 0.5), (int) (c.y + 0.5), 1, Color.RED); } } if (calibGUI.doShowGraph) { System.out.println("Maybe I should add this back in with the new detector some how"); } gui.setBufferedImage(workImage); gui.setScale(calibGUI.getScale()); gui.repaint(); processed = true; }
public static void extractImage( String rootDir, String scaledDir, long subjectId, long imageId, String fileName, int haarMinSize, int scaledSize) throws IOException { FileInputStream input = new FileInputStream(fileName); MBFImage image = ImageUtilities.readMBF(input); BufferedImage detectedFacesImage = ImageIO.read(new File(fileName)); // ImageUtils.displayImage(detectedFacesImage); FaceDetector<DetectedFace, FImage> fd = new HaarCascadeDetector(haarMinSize); List<DetectedFace> faces = fd.detectFaces(Transforms.calculateIntensity(image)); System.out.println("# Found faces, one per line."); System.out.println("# <x>, <y>, <width>, <height>"); Iterator<DetectedFace> iterator = faces.iterator(); BufferedImage extractFaceImage = null; if (iterator.hasNext()) { DetectedFace face = iterator.next(); Rectangle bounds = face.getBounds(); // extractFaceImage = detectedFacesImage.getSubimage((int)bounds.x, (int)bounds.y, // (int)bounds.width, (int)bounds.height); // writeImage(extractFaceImage, rootDir, "extracted", subjectId, imageId); // BufferedImage scaledBufferedImage = scale(extractFaceImage, scaledSize); // String scaledFileName = scaledDir + subjectId + "-" + imageId + ".jpg"; // System.out.println("scaledFileName = " + scaledFileName); // ImageIO.write(scaledBufferedImage, "jpg", new File(scaledFileName)); Graphics g = detectedFacesImage.createGraphics(); g.setColor(Color.GREEN); g.drawRect((int) bounds.x, (int) bounds.y, (int) bounds.width, (int) bounds.height); System.out.println(bounds.x + ";" + bounds.y + ";" + bounds.width + ";" + bounds.height); } else { Graphics g = detectedFacesImage.createGraphics(); g.setColor(Color.GREEN); g.drawString("No Image Detected", 20, 20); } writeImage(detectedFacesImage, rootDir, "detected", subjectId, imageId); // // FaceDetector < KEDetectedFace , FImage > fdK = new FKEFaceDetector () ; // List < KEDetectedFace > facesK = fdK.detectFaces ( Transforms.calculateIntensity ( // image ) ) ; // if (!facesK.isEmpty()) { // System.out.println("Found face"); // KEDetectedFace detectedKeyFace = facesK.get(0); // FacialKeypoint[] keypoints = detectedKeyFace.getKeypoints(); // for (FacialKeypoint keypoint: keypoints) { // System.out.println("keypoint:" + keypoint); // } // } }
static BufferedImage getCompositeImage(BufferedImage baseFrame, BufferedImage topFrame) { // create top Image Graphics2D graphics2D = topFrame.createGraphics(); graphics2D.drawImage(topFrame, null, 0, 0); graphics2D.dispose(); // draw top on top of baseFrame Graphics2D graphics2D1 = baseFrame.createGraphics(); graphics2D1.drawImage(topFrame, null, 0, 0); graphics2D1.dispose(); return ResourceManager.newFrame(baseFrame); }
/** * This function is used to draw very thin white borders over the outer edge of the raster map. * It's necessary because the map edge "bleeds" into the adjacent pixels, and we need to cover * that. * * <p>I think this quirky behaviour is possibly an iText bug */ private void addWhiteMapBorder(Image img, Document doc) { try { Color color = Color.white; int borderWidth = 1; BufferedImage bufferedTop = new BufferedImage((int) img.getScaledWidth(), borderWidth, BufferedImage.TYPE_INT_RGB); Graphics2D g1 = bufferedTop.createGraphics(); g1.setBackground(color); g1.clearRect(0, 0, bufferedTop.getWidth(), bufferedTop.getHeight()); Image top = Image.getInstance(bufferedImage2ByteArray(bufferedTop)); top.setAbsolutePosition( img.getAbsoluteX(), img.getAbsoluteY() + img.getScaledHeight() - bufferedTop.getHeight() / 2); BufferedImage bufferedBottom = new BufferedImage((int) img.getScaledWidth(), borderWidth, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = bufferedBottom.createGraphics(); g2.setBackground(color); g2.clearRect(0, 0, bufferedBottom.getWidth(), bufferedBottom.getHeight()); Image bottom = Image.getInstance(bufferedImage2ByteArray(bufferedBottom)); bottom.setAbsolutePosition( img.getAbsoluteX(), img.getAbsoluteY() - bufferedTop.getHeight() / 2); BufferedImage bufferedLeft = new BufferedImage(borderWidth, (int) img.getScaledHeight(), BufferedImage.TYPE_INT_RGB); Graphics2D g3 = bufferedLeft.createGraphics(); g3.setBackground(color); g3.clearRect(0, 0, bufferedLeft.getWidth(), bufferedLeft.getHeight()); Image left = Image.getInstance(bufferedImage2ByteArray(bufferedLeft)); left.setAbsolutePosition( img.getAbsoluteX() - bufferedLeft.getWidth() / 2, img.getAbsoluteY()); BufferedImage bufferedRight = new BufferedImage(borderWidth, (int) img.getScaledHeight(), BufferedImage.TYPE_INT_RGB); Graphics2D g4 = bufferedRight.createGraphics(); g4.setBackground(color); g4.clearRect(0, 0, bufferedRight.getWidth(), bufferedRight.getHeight()); Image right = Image.getInstance(bufferedImage2ByteArray(bufferedRight)); right.setAbsolutePosition( img.getAbsoluteX() + img.getScaledWidth() - bufferedRight.getWidth() / 2, img.getAbsoluteY()); doc.add(top); doc.add(bottom); doc.add(left); doc.add(right); } catch (Exception e) { e.printStackTrace(); } }
public QuadraticForm(String nonRadical, String radical, String denominator) { BufferedImage sample = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB); Graphics2D g = sample.createGraphics(); int fontHeight = g.getFontMetrics().getHeight(); int fontDip = g.getFontMetrics().getDescent(); int nonRadicalWidth = g.getFontMetrics().stringWidth(nonRadical + " + "); int expInsert = 0; if (radical.indexOf("^") > -1) { String sub = radical.substring(0, radical.indexOf("^")); radical = radical.replace("^2", " "); expInsert = nonRadicalWidth + g.getFontMetrics().stringWidth(sub); } int radicalWidth = g.getFontMetrics().stringWidth(radical); int denominatorWidth = g.getFontMetrics().stringWidth(denominator); width = nonRadicalWidth + radicalWidth; height = 2 * fontHeight + 2 * fontDip + 5; equation = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = equation.createGraphics(); g2.setColor(Color.BLACK); g2.drawString(nonRadical + " ± ", 0, fontHeight); g2.drawString(radical, nonRadicalWidth, fontHeight); g2.drawString(denominator, (width - denominatorWidth) / 2, fontDip + 2 * fontHeight); g2.drawLine(nonRadicalWidth, 3, width, 3); g2.drawLine(0, fontHeight + fontDip, width, fontHeight + fontDip); g2.setFont(new Font("Times", Font.PLAIN, 8)); int expHeight = g2.getFontMetrics().getHeight(); if (expInsert != 0) g2.drawString(2 + "", expInsert, expHeight + 3); }
static { BufferedImage bi = new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB); Graphics2D gi = bi.createGraphics(); gi.setBackground(Color.white); gi.clearRect(0, 0, 10, 10); GeneralPath p1 = new GeneralPath(); p1.moveTo(0, 0); p1.lineTo(5, 10); p1.lineTo(10, 0); p1.closePath(); gi.setColor(Color.lightGray); gi.fill(p1); triangles = new TexturePaint(bi, new Rectangle(0, 0, 10, 10)); bi = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB); gi = bi.createGraphics(); gi.setColor(Color.black); gi.fillRect(0, 0, 5, 5); gi.setColor(Color.gray); gi.fillRect(1, 1, 4, 4); blacklines = new TexturePaint(bi, new Rectangle(0, 0, 5, 5)); int w = 30; int h = 30; bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); gi = bi.createGraphics(); Color oc = Color.white; Color ic = Color.lightGray; gi.setPaint(new GradientPaint(0, 0, oc, w * .35f, h * .35f, ic)); gi.fillRect(0, 0, w / 2, h / 2); gi.setPaint(new GradientPaint(w, 0, oc, w * .65f, h * .35f, ic)); gi.fillRect(w / 2, 0, w / 2, h / 2); gi.setPaint(new GradientPaint(0, h, oc, w * .35f, h * .65f, ic)); gi.fillRect(0, h / 2, w / 2, h / 2); gi.setPaint(new GradientPaint(w, h, oc, w * .65f, h * .65f, ic)); gi.fillRect(w / 2, h / 2, w / 2, h / 2); gradient = new TexturePaint(bi, new Rectangle(0, 0, w, h)); bi = new BufferedImage(2, 2, BufferedImage.TYPE_INT_RGB); bi.setRGB(0, 0, 0xffffffff); bi.setRGB(1, 0, 0xffffffff); bi.setRGB(0, 1, 0xffffffff); bi.setRGB(1, 1, 0xff0000ff); bluedots = new TexturePaint(bi, new Rectangle(0, 0, 2, 2)); bi = new BufferedImage(2, 2, BufferedImage.TYPE_INT_RGB); bi.setRGB(0, 0, 0xffffffff); bi.setRGB(1, 0, 0xffffffff); bi.setRGB(0, 1, 0xffffffff); bi.setRGB(1, 1, 0xff00ff00); greendots = new TexturePaint(bi, new Rectangle(0, 0, 2, 2)); }
/** * Returns inner shade nine-patch icon. * * @param shadeWidth shade width * @param round corners round * @param shadeOpacity shade opacity * @return inner shade nine-patch icon */ public static NinePatchIcon createInnerShadeIcon( final int shadeWidth, final int round, final float shadeOpacity) { // Calculating width for temprorary image final int inner = Math.max(shadeWidth, round); int width = shadeWidth * 2 + inner * 2; // Creating template image final BufferedImage bi = new BufferedImage(width, width, BufferedImage.TYPE_INT_ARGB); final Graphics2D ig = bi.createGraphics(); GraphicsUtils.setupAntialias(ig); final Area area = new Area(new Rectangle(0, 0, width, width)); area.exclusiveOr( new Area( new RoundRectangle2D.Double( shadeWidth, shadeWidth, width - shadeWidth * 2, width - shadeWidth * 2, round * 2, round * 2))); ig.setPaint(Color.BLACK); ig.fill(area); ig.dispose(); // Creating shade image final ShadowFilter sf = new ShadowFilter(shadeWidth, 0, 0, shadeOpacity); final BufferedImage shade = sf.filter(bi, null); // Clipping shade image final Graphics2D g2d = shade.createGraphics(); GraphicsUtils.setupAntialias(g2d); g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_IN)); g2d.setPaint(FlatLafStyleConstants.transparent); g2d.fill(area); g2d.dispose(); final BufferedImage croppedShade = shade.getSubimage(shadeWidth, shadeWidth, width - shadeWidth * 2, width - shadeWidth * 2); width = croppedShade.getWidth(); // Creating nine-patch icon final NinePatchIcon ninePatchIcon = NinePatchIcon.create(croppedShade); ninePatchIcon.addHorizontalStretch(0, inner, true); ninePatchIcon.addHorizontalStretch(inner + 1, width - inner - 1, false); ninePatchIcon.addHorizontalStretch(width - inner, width, true); ninePatchIcon.addVerticalStretch(0, inner, true); ninePatchIcon.addVerticalStretch(inner + 1, width - inner - 1, false); ninePatchIcon.addVerticalStretch(width - inner, width, true); ninePatchIcon.setMargin(shadeWidth); return ninePatchIcon; }
private <T> T scaleImageUsingAffineTransformation(final BufferedImage bufferedImage, T target) { BufferedImage destinationImage = generateDestinationImage(); Graphics2D graphics2D = destinationImage.createGraphics(); AffineTransform transformation = AffineTransform.getScaleInstance( ((double) getQualifiedWidth() / bufferedImage.getWidth()), ((double) getQualifiedHeight() / bufferedImage.getHeight())); graphics2D.drawRenderedImage(bufferedImage, transformation); graphics2D.addRenderingHints(retrieveRenderingHints()); try { if (target instanceof File) { LOGGER.info(String.format(M_TARGET_TYPE_OF, "File")); ImageIO.write(destinationImage, imageType.toString(), (File) target); } else if (target instanceof ImageOutputStream) { LOGGER.info(String.format(M_TARGET_TYPE_OF, "ImageOutputStream")); ImageIO.write(destinationImage, imageType.toString(), (ImageOutputStream) target); } else if (target instanceof OutputStream) { LOGGER.info(String.format(M_TARGET_TYPE_OF, "OutputStream")); ImageIO.write(destinationImage, imageType.toString(), (OutputStream) target); } else { target = null; } } catch (IOException e) { e.printStackTrace(); } return target; }
@Override public RenderedImage scaleImage(Image image, int width, int height) { // Draw the given image to a buffered image object and scale it to the new size on-the-fly. int imageType = BufferedImage.TYPE_4BYTE_ABGR; if (image instanceof BufferedImage) { imageType = ((BufferedImage) image).getType(); if (imageType == BufferedImage.TYPE_BYTE_INDEXED || imageType == BufferedImage.TYPE_BYTE_BINARY || imageType == BufferedImage.TYPE_CUSTOM) { // INDEXED and BINARY: GIFs or indexed PNGs may lose their transparent bits, for safety // revert to ABGR. // CUSTOM: Unknown image type, fall back on ABGR. imageType = BufferedImage.TYPE_4BYTE_ABGR; } } BufferedImage bufferedImage = new BufferedImage(width, height, imageType); Graphics2D graphics2D = bufferedImage.createGraphics(); graphics2D.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); // We should test the return code here because an exception can be throw but caught. if (!graphics2D.drawImage(image, 0, 0, width, height, null)) { // Conversion failed. throw new RuntimeException("Failed to resize image."); } return bufferedImage; }
/** * 将照片logo添加到二维码中间 * * @param image 生成的二维码照片对象 * @param imagePath 照片保存路径 * @param logoPath logo照片路径 * @param formate 照片格式 */ public static void overlapImage( BufferedImage image, String formate, String imagePath, String logoPath, MatrixToLogoImageConfig logoConfig) { try { BufferedImage logo = ImageIO.read(new File(logoPath)); Graphics2D g = image.createGraphics(); // 考虑到logo照片贴到二维码中,建议大小不要超过二维码的1/5; int width = image.getWidth() / logoConfig.getLogoPart(); int height = image.getHeight() / logoConfig.getLogoPart(); // logo起始位置,此目的是为logo居中显示 int x = (image.getWidth() - width) / 2; int y = (image.getHeight() - height) / 2; // 绘制图 g.drawImage(logo, x, y, width, height, null); // 给logo画边框 // 构造一个具有指定线条宽度以及 cap 和 join 风格的默认值的实心 BasicStroke g.setStroke(new BasicStroke(logoConfig.getBorder())); g.setColor(logoConfig.getBorderColor()); g.drawRect(x, y, width, height); g.dispose(); // 写入logo照片到二维码 ImageIO.write(image, formate, new File(imagePath)); } catch (Exception e) { e.printStackTrace(); } }
@Test public void testTranslatedImage() { BufferedImage image = new BufferedImage(256, 256, BufferedImage.TYPE_BYTE_GRAY); Graphics g = image.createGraphics(); g.setColor(Color.WHITE); g.fillRect(236, 236, 20, 20); g.setColor(new Color(80, 80, 80)); // A dark gray g.fillRect(216, 216, 20, 20); g.setColor(new Color(200, 200, 200)); // A light gray g.fillRect(216, 236, 20, 20); g.dispose(); image = image.getSubimage(128, 128, 128, 128); CustomPaletteBuilder builder = new CustomPaletteBuilder(image, 256, 1, 1, 1); RenderedImage indexed = builder.buildPalette().getIndexedImage(); assertTrue(indexed.getColorModel() instanceof IndexColorModel); IndexColorModel icm = (IndexColorModel) indexed.getColorModel(); assertEquals( 4, icm .getMapSize()); // Black background, white fill, light gray fill, dark gray fill = 4 // colors // check image not black ImageWorker iw = new ImageWorker(indexed).forceComponentColorModel().intensity(); double[] mins = iw.getMinimums(); double[] maxs = iw.getMaximums(); boolean result = true; for (int i = 0; i < mins.length; i++) { result = mins[i] == maxs[i] ? false : result; } assertTrue(result); }
private BufferedImage scale(BufferedImage image, int newWidth, int newHeight) { float width; float height; if (newWidth <= 0 || newHeight <= 0) { logger.warn("Invalid scale attempt aborted."); return null; } width = (float) newWidth / (float) image.getWidth(); height = (float) newHeight / (float) image.getHeight(); BufferedImage out = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = out.createGraphics(); RenderingHints qualityHints = new RenderingHints( RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ANTIALIAS_ON); qualityHints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g2.setRenderingHints(qualityHints); AffineTransform at = AffineTransform.getScaleInstance(width, height); g2.drawImage(image, at, null); g2.dispose(); return out; }
/* applet init event. Should initialize the applet. */ public void init() { backbuffer = new BufferedImage(512, 512, BufferedImage.TYPE_INT_ARGB); g2d = backbuffer.createGraphics(); iconSheet = getImage(this.getClass().getResource("data/icons2.png")); wateringCanImage = getImageFromIconSheet(0, 0); wateringSplashImage = getImageFromIconSheet(1, 0); flowerImage = getImageFromIconSheet(2, 0); seedImage = getImageFromIconSheet(3, 0); skullImage = getImageFromIconSheet(4, 0); tapImage = getImageFromIconSheet(5, 0); playerImage = getImageFromIconSheet(0, 1); flowerStalkImage = getImageFromIconSheet(2, 1); clockImage = getImageFromIconSheet(4, 1); tapSplashImage = getImageFromIconSheet(5, 1); dirtImage = getImageFromIconSheet(0, 2); brickImage = getImageFromIconSheet(0, 3); player.image = playerImage; pickupAudio = getAudioClip(this.getClass().getResource("data/Pickup.wav")); for (int i = 0; i < 14; i++) { flowerList[i] = new Flower(); flowerList[i].height = rand.nextInt(14); } addKeyListener(this); }
/** * 插入LOGO * * @param source 二维码图片 * @param imgPath LOGO图片地址 * @param needCompress 是否压缩 * @throws Exception */ private static void insertImage(BufferedImage source, String imgPath, boolean needCompress) throws Exception { File file = new File(imgPath); if (!file.exists()) { System.err.println("" + imgPath + " 该文件不存在!"); return; } Image src = ImageIO.read(new File(imgPath)); int width = src.getWidth(null); int height = src.getHeight(null); if (needCompress) { // 压缩LOGO if (width > WIDTH) { width = WIDTH; } if (height > HEIGHT) { height = HEIGHT; } Image image = src.getScaledInstance(width, height, Image.SCALE_SMOOTH); BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics g = tag.getGraphics(); g.drawImage(image, 0, 0, null); // 绘制缩小后的图 g.dispose(); src = image; } // 插入LOGO Graphics2D graph = source.createGraphics(); int x = (QRCODE_WIDTH - width) / 2; int y = (QRCODE_HEIGHT - height) / 2; graph.drawImage(src, x, y, width, height, null); Shape shape = new RoundRectangle2D.Float(x, y, width, width, 6, 6); graph.setStroke(new BasicStroke(3f)); graph.draw(shape); graph.dispose(); }
public void run() { BufferedImage img = panel.getImage(); Graphics2D g2 = img.createGraphics(); int anzahl = 255; int st = 6; int r = st / 2; int x1, y1; int c; Random random = new Random(); MyColor myColor = MyColor.getInstance(); for (int y = 0; y < img.getHeight(); y += st) { for (Integer x = 0; x < img.getWidth(); x += st) { int color = img.getRGB(x, y); if (color != RED && color != WHITE) { c = 0; for (int i = 0; i < anzahl; i++) { x1 = x; y1 = y; color = BLACK; while (color != RED && color != WHITE) { x1 += random.nextBoolean() ? 5 : -5; y1 += random.nextBoolean() ? 5 : -5; color = img.getRGB(x1, y1); } if (color == RED) { c += 1; } } System.out.println("Point(" + x + "," + y + ") c=" + c); g2.setColor(myColor.getColorAt(c)); g2.fillOval(x - r, y - r, st, st); } } } }
void registerImage(URL imageURL) { if (loadedImages.containsKey(imageURL)) { return; } SoftReference ref; try { String fileName = imageURL.getFile(); if (".svg".equals(fileName.substring(fileName.length() - 4).toLowerCase())) { SVGIcon icon = new SVGIcon(); icon.setSvgURI(imageURL.toURI()); BufferedImage img = new BufferedImage( icon.getIconWidth(), icon.getIconHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D g = img.createGraphics(); icon.paintIcon(null, g, 0, 0); g.dispose(); ref = new SoftReference(img); } else { BufferedImage img = ImageIO.read(imageURL); ref = new SoftReference(img); } loadedImages.put(imageURL, ref); } catch (Exception e) { Logger.getLogger(SVGConst.SVG_LOGGER) .log(Level.WARNING, "Could not load image: " + imageURL, e); } }
/** * returns the resized and cliped img. * * @param img * @param newW * @param newH * @return */ private static BufferedImage resizeclip(BufferedImage img, int newW, int newH) { int startx, width, starty, height; int w = img.getWidth(); int h = img.getHeight(); double sourceVer = 1.0 * h / w; double targetVer = 1.0 * newH / newW; if (sourceVer < targetVer) { starty = 0; height = h; startx = (int) (((1.0 * newH / h * w - newW) / 2) * 1.0 * h / newH); width = startx + (int) (newW * 1.0 * h / newH); } else { startx = 0; width = w; starty = (int) (((1.0 * newW / w * h - newH) / 2) * 1.0 * w / newW); height = starty + (int) (newH * 1.0 * w / newW); } BufferedImage dimg = new BufferedImage(newW, newH, img.getType()); Graphics2D g = dimg.createGraphics(); g.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g.drawImage(img, 0, 0, newW, newH, startx, starty, width, height, null); g.dispose(); return dimg; }
public void run(String[] args) { File inDir = new File("input/SampleZoomLevel"); File outFile = new File("output/SampleZoomLevel/map.png"); File[] fileList = inDir.listFiles(); int i; // Stitching a map with 4 rows and 4 columns; the program is generalized, // so you can use higher multiples of 4, such as 8 by 8 and 16 by 16. int rows = 4; int cols = 4; int total = rows * cols; BufferedImage images[] = new BufferedImage[total]; try { for (i = 0; i < total; i++) { File inFile = fileList[i]; int c1; int c2; // The code below deals with the naming convention we use // for each map tile. // See the ReadMe for more on the naming convention. String s = inFile.getName().substring(0, 2); c1 = Integer.parseInt(s); s = inFile.getName().substring(3, 5); c2 = Integer.parseInt(s); BufferedImage image = null; image = ImageIO.read(inFile); images[c1 * cols + c2] = image; } } catch (IOException e) { System.err.println(e); System.exit(1); } // Our map tiles are square, with dimensions of 256 by 256 pixels. With 4 rows and //4 // columns, we create a 1024 by 1024 image. BufferedImage outputImage = new BufferedImage(256 * cols, 256 * rows, BufferedImage.TYPE_INT_ARGB_PRE); Graphics2D g = outputImage.createGraphics(); // Loop through the rows and columns for (i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { g.drawImage(images[i * cols + j], j * 256, i * 256, 256, 256, null); } } try { ImageIO.write(outputImage, "png", outFile); } catch (IOException e) { System.err.println(e); System.exit(1); } }
public void update(long elapsedTime) { if (visible && timer.action(elapsedTime)) { this.tmp_img = GraphicsUtils.createImage(width, height, true); this.graphics2D = tmp_img.createGraphics(); for (int i = 0; i < max; i++) { if (maxs[i] == flag || maxs[i] == -flag) { bools[i] = !bools[i]; } maxs[i] += bools[i] ? 1 : -1; if (d[i] == 0 && (matching == i || matching < 0 && abs(randx - xs[i] - sakura_width / 2) < sakura_width / 2 && abs(randy - ys[i] - sakura_height / 2) < sakura_height / 2)) { xs[i] = randx - sakura_width / 2; ys[i] = randy - sakura_height / 2; maxs[i] = 0; matching = i; } else { xs[i] += maxs[i]; if (ys[i] < height) { ys[i] += s[i]; } else { xs[i] = (int) (LSystem.random.nextFloat() * (width - 1)); ys[i] = -(int) (LSystem.random.nextFloat() * 1) - images[d[i]].getHeight(null); } } this.tmp_x = xs[i]; this.tmp_y = ys[i]; graphics2D.drawImage(images[d[i]], tmp_x, tmp_y, null); } } }
private BufferedImage resizeImg(InputStream inputStream) throws IOException { BufferedImage originalImage = ImageIO.read(inputStream); int width = originalImage.getWidth(); int height = originalImage.getHeight(); int newWidth = width; int newHeight = height; // Ajusta o height de acordo com o min width if (width > MAX_WIDTH) { newWidth = MAX_WIDTH; newHeight = (newWidth * height) / width; width = newWidth; height = newHeight; } // Ajusta o width de acordo com o min height if (height > MAX_HEIGHT) { newHeight = MAX_HEIGHT; newWidth = (newHeight * width) / height; width = newWidth; height = newHeight; } BufferedImage resizedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics2D g = resizedImage.createGraphics(); g.drawImage(originalImage, 0, 0, width, height, null); g.dispose(); return resizedImage; }
/** * Draws contours. Internal and external contours are different user specified colors. * * @param contours List of contours * @param colorExternal RGB color * @param colorInternal RGB color * @param width Image width * @param height Image height * @param out (Optional) storage for output image * @return Rendered contours */ public static BufferedImage renderContours( List<Contour> contours, int colorExternal, int colorInternal, int width, int height, BufferedImage out) { if (out == null) { out = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); } else { Graphics2D g2 = out.createGraphics(); g2.setColor(Color.BLACK); g2.fillRect(0, 0, width, height); } for (Contour c : contours) { for (Point2D_I32 p : c.external) { out.setRGB(p.x, p.y, colorExternal); } for (List<Point2D_I32> l : c.internal) { for (Point2D_I32 p : l) { out.setRGB(p.x, p.y, colorInternal); } } } return out; }
/** * returns the resized img with black bars. * * @param img * @param newW * @param newH * @return */ private static BufferedImage resize(BufferedImage img, int newW, int newH) { int startx, wide, starty, hight; int w = img.getWidth(); int h = img.getHeight(); double sourceVer = 1.0 * h / w; double targetVer = 1.0 * newH / newW; if (sourceVer < targetVer) { startx = 0; wide = newW; hight = (int) 1.0 * newW / w * h; starty = (int) (newH - hight) / 2; hight += starty; } else { starty = 0; hight = newH; wide = (int) 1.0 * newH / h * w; startx = (int) (newW - wide) / 2; wide += startx; } BufferedImage dimg = dimg = new BufferedImage(newW, newH, img.getType()); Graphics2D g = dimg.createGraphics(); g.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); Color color = new Color(0, 0, 0); g.setColor(color); g.fillRect(0, 0, startx == 0 ? newW : startx, starty == 0 ? newH : starty); g.drawImage(img, startx, starty, wide, hight, 0, 0, w, h, null); g.fillRect( startx == 0 ? 0 : wide, starty == 0 ? 0 : hight, startx == 0 ? newW : startx, starty == 0 ? newH : starty); g.dispose(); return dimg; }
/** * Returns the specified image as icon. * * @param name name of icon * @return icon */ public static ImageIcon icon(final String name) { ImageIcon ii = ICONS.get(name); if (ii != null) return ii; Image img; if (GUIConstants.scale > 1) { // choose large image or none final URL url = GUIConstants.large() ? BaseXImages.class.getResource("/img/" + name + "_32.png") : null; if (url == null) { // resize low-res image if no hi-res image exists img = get(url(name)); final int w = (int) (img.getWidth(null) * GUIConstants.scale); final int h = (int) (img.getHeight(null) * GUIConstants.scale); final BufferedImage tmp = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); final Graphics2D g2 = tmp.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g2.drawImage(img, 0, 0, w, h, null); g2.dispose(); img = tmp; } else { img = get(url); } } else { img = get(name); } ii = new ImageIcon(img); ICONS.put(name, ii); return ii; }
@Override public void setup() { super.setup(); int sWidth = overrideData.getWidth(); int sHeight = overrideData.getHeight(); pixels = new int[tileSizeSquare]; if (tileSizeBase == sWidth && tileSizeBase == sHeight) { overrideData.getRGB(0, 0, sWidth, sHeight, pixels, 0, sWidth); } else { BufferedImage tmp = new BufferedImage(tileSizeBase, tileSizeBase, 6); Graphics2D gfx = tmp.createGraphics(); gfx.drawImage( overrideData, 0, 0, tileSizeBase, tileSizeBase, 0, 0, sWidth, sHeight, (ImageObserver) null); tmp.getRGB(0, 0, tileSizeBase, tileSizeBase, pixels, 0, tileSizeBase); gfx.dispose(); } update(); }
public static BufferedImage renderContours( List<EdgeContour> edges, int colors[], int width, int height, BufferedImage out) { if (out == null) { out = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); } else { Graphics2D g2 = out.createGraphics(); g2.setColor(Color.BLACK); g2.fillRect(0, 0, width, height); } colors = checkColors(colors, edges.size()); for (int i = 0; i < edges.size(); i++) { EdgeContour e = edges.get(i); int color = colors[i]; for (EdgeSegment s : e.segments) { for (Point2D_I32 p : s.points) { out.setRGB(p.x, p.y, color); } } } return out; }