public void fitSize() { BufferedImage bi = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB); FontMetrics fm = bi.getGraphics().getFontMetrics(font); java.awt.geom.Rectangle2D rect = fm.getStringBounds(text, bi.getGraphics()); w = rect.getWidth() + font.getSize(); h = rect.getHeight(); }
private void createShadowBorder() { backgroundImage = new BufferedImage( getWidth() + SHADOW_WIDTH, getHeight() + SHADOW_WIDTH, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = (Graphics2D) backgroundImage.getGraphics(); try { Robot robot = new Robot(getGraphicsConfiguration().getDevice()); BufferedImage capture = robot.createScreenCapture( new Rectangle(getX(), getY(), getWidth() + SHADOW_WIDTH, getHeight() + SHADOW_WIDTH)); g2.drawImage(capture, null, 0, 0); } catch (AWTException e) { e.printStackTrace(); } BufferedImage shadow = new BufferedImage( getWidth() + SHADOW_WIDTH, getHeight() + SHADOW_WIDTH, BufferedImage.TYPE_INT_ARGB); Graphics graphics = shadow.getGraphics(); graphics.setColor(new Color(0.0f, 0.0f, 0.0f, 0.3f)); graphics.fillRoundRect(6, 6, getWidth(), getHeight(), 12, 12); g2.drawImage(shadow, getBlurOp(7), 0, 0); }
/** * Converts an image (RGB, RGBA, ... whatever) to a binary one based on given threshold * * @param image the image to convert. Remains untouched. * @param threshold the threshold in [0,255] * @return a new BufferedImage instance of TYPE_BYTE_GRAY with only 0'S and 255's */ private static BufferedImage thresholdImage(Image imgIn, Image imgOut, int threshold) { if (imgOut.getBufferedImage().getType() != BufferedImage.TYPE_BYTE_GRAY) { final BufferedImage result = new BufferedImage(imgIn.getWidth(), imgIn.getHeight(), BufferedImage.TYPE_BYTE_GRAY); final Graphics g = result.getGraphics(); g.drawImage(imgIn.getBufferedImage(), 0, 0, null); g.dispose(); imgOut.setBufferedImage(result); System.err.println("Image was converted into BufferedImage.TYPE_BYTE_GRAY type"); } BufferedImage result = imgOut.getBufferedImage(); result.getGraphics().drawImage(imgIn.getBufferedImage(), 0, 0, null); WritableRaster raster = result.getRaster(); int[] pixels = new int[imgIn.getWidth()]; for (int y = 0; y < imgIn.getHeight(); y++) { raster.getPixels(0, y, imgIn.getWidth(), 1, pixels); for (int i = 0; i < pixels.length; i++) { pixels[i] = (pixels[i] < threshold) ? 0 : 255; } raster.setPixels(0, y, imgIn.getWidth(), 1, pixels); } return result; }
private BufferedImage getFontImage(char ch) { // Create a temporary image to extract the character's size BufferedImage tempfontImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB); Graphics2D g = (Graphics2D) tempfontImage.getGraphics(); if (antiAlias == true) { g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); } g.setFont(font); fontMetrics = g.getFontMetrics(); int charwidth = fontMetrics.charWidth(ch) + 8; if (charwidth <= 0) { charwidth = 7; } int charheight = fontMetrics.getHeight() + 3; if (charheight <= 0) { charheight = fontSize; } // Create another image holding the character we are creating BufferedImage fontImage; fontImage = new BufferedImage(charwidth, charheight, BufferedImage.TYPE_INT_ARGB); Graphics2D gt = (Graphics2D) fontImage.getGraphics(); if (antiAlias == true) { gt.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); } gt.setFont(font); gt.setColor(Color.WHITE); int charx = 3; int chary = 1; gt.drawString(String.valueOf(ch), (charx), (chary) + fontMetrics.getAscent()); return fontImage; }
private void paintToImage( final BufferedImage img, final int x, final int y, final int width, final int height) { // clear the prior image Graphics2D imgG = (Graphics2D) img.getGraphics(); imgG.setComposite(AlphaComposite.Clear); imgG.setColor(Color.black); imgG.fillRect(0, 0, width + blur * 2, height + blur * 2); final int adjX = (int) (x + blur + offsetX + (insets.left * distance)); final int adjY = (int) (y + blur + offsetY + (insets.top * distance)); final int adjW = (int) (width - (insets.left + insets.right) * distance); final int adjH = (int) (height - (insets.top + insets.bottom) * distance); // let the delegate paint whatever they want to be blurred imgG.setComposite(AlphaComposite.DstAtop); if (prePainter != null) prePainter.paint(imgG, adjX, adjY, adjW, adjH); imgG.dispose(); // blur the prior image back into the same pixels imgG = (Graphics2D) img.getGraphics(); imgG.setComposite(AlphaComposite.DstAtop); imgG.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); imgG.setRenderingHint( RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY); imgG.drawImage(img, blurOp, 0, 0); if (postPainter != null) postPainter.paint(imgG, adjX, adjY, adjW, adjH); imgG.dispose(); }
private static ImageElement fetchImageProperties( final BufferedImage source, final ImageType imageType, final String id, final Date modifiedDate, final String mimeType) throws NullPointerException, IOException { if (verifyNotNull(source)) { ImageElement image = new ImageElement(); image.setBitDepth( verifyNotNull(source.getColorModel().getPixelSize()) ? source.getColorModel().getPixelSize() : 0); image.setHeight(verifyNotNull(source.getHeight()) ? source.getHeight() : 0); image.setWidth(verifyNotNull(source.getWidth()) ? source.getWidth() : 0); image.setSizeInBytes(determineSizeOfBufferedImage(source, imageType.toString())); image.setCreated(new Date(System.currentTimeMillis())); image.setTransparent( determineTransparencyType(source.getGraphics().getColor().getTransparency())); if (verifyNotNull(modifiedDate)) image.setModified(modifiedDate); image.setId((verifyNotNull(id) ? id : "")); image.setFontType( verifyNotNull(source.getGraphics().getFont()) ? source.getGraphics().getFont() : new Font("Default", 0, 0)); image.setMediaType(MediaType.Missing); return image; } throw new NullPointerException(E_OBJECT_WAS_NULL); }
public static void updateMetrics() { BufferedImage junkst = TexI.mkbuf(new Coord(10, 10)); STANDALONE = junkst.getGraphics(); BufferedImage junk = TexI.mkbuf(new Coord(10, 10)); CONTEXT = junk.getGraphics(); CONTEXT.setFont(FONT); METRICS = CONTEXT.getFontMetrics(); }
/** @return the bitmapFont */ public Font getBitmapFont() { Font bitmapFont = Font.getBitmapFont(lookupFont); if (bitmapFont != null) { return bitmapFont; } BufferedImage image = new BufferedImage(5000, 50, BufferedImage.TYPE_INT_RGB); Graphics2D g2d = (Graphics2D) image.getGraphics(); g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g2d.setRenderingHint( RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY); g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE); g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, bitmapAntialiasing); g2d.setColor(Color.BLACK); g2d.fillRect(0, 0, image.getWidth(), image.getHeight()); g2d.setColor(new Color(0xff0000)); g2d.setFont(java.awt.Font.decode(lookupFont.split(";")[0])); FontMetrics metrics = g2d.getFontMetrics(); FontRenderContext context = g2d.getFontRenderContext(); int height = (int) Math.ceil(metrics.getMaxDescent() + metrics.getMaxAscent()); int baseline = (int) Math.ceil(metrics.getMaxAscent()); String charsetStr = bitmapCharset; int[] offsets = new int[charsetStr.length()]; int[] widths = new int[offsets.length]; int currentOffset = 0; for (int iter = 0; iter < charsetStr.length(); iter++) { offsets[iter] = currentOffset; String currentChar = charsetStr.substring(iter, iter + 1); g2d.drawString(currentChar, currentOffset, baseline); Rectangle2D rect = g2d.getFont().getStringBounds(currentChar, context); widths[iter] = (int) Math.ceil(rect.getWidth()); // max advance works but it makes a HUGE image in terms of width which // occupies more ram if (g2d.getFont().isItalic()) { currentOffset += metrics.getMaxAdvance(); } else { currentOffset += widths[iter] + 1; } } g2d.dispose(); BufferedImage shrunk = new BufferedImage(currentOffset, height, BufferedImage.TYPE_INT_RGB); g2d = (Graphics2D) shrunk.getGraphics(); g2d.drawImage(image, 0, 0, null); g2d.dispose(); int[] rgb = new int[shrunk.getWidth() * shrunk.getHeight()]; shrunk.getRGB(0, 0, shrunk.getWidth(), shrunk.getHeight(), rgb, 0, shrunk.getWidth()); com.sun.lwuit.Image bitmap = com.sun.lwuit.Image.createImage(rgb, shrunk.getWidth(), shrunk.getHeight()); return com.sun.lwuit.Font.createBitmapFont(lookupFont, bitmap, offsets, widths, charsetStr); }
@SuppressWarnings("UndesirableClassUsage") private static void assertImagesSimilar( String name, BufferedImage expected, BufferedImage actual, float allowedDifference) throws Exception { BufferedImage convertedExpected = new BufferedImage(expected.getWidth(), expected.getHeight(), BufferedImage.TYPE_INT_ARGB); convertedExpected.getGraphics().drawImage(expected, 0, 0, null); BufferedImage convertedActual = new BufferedImage(actual.getWidth(), actual.getHeight(), BufferedImage.TYPE_INT_ARGB); convertedActual.getGraphics().drawImage(actual, 0, 0, null); assertImageSimilar(name, convertedExpected, convertedActual, allowedDifference); }
public void createBuffer() { buffer = new BufferedImage( Orig.getWidth(null), Orig.getHeight(null), BufferedImage.TYPE_4BYTE_ABGR_PRE); Graphics temp = buffer.getGraphics(); temp.drawImage(Orig, 0, 0, null); contBuffer = new BufferedImage( Cont.getWidth(null), Cont.getHeight(null), BufferedImage.TYPE_4BYTE_ABGR_PRE); temp = contBuffer.getGraphics(); temp.drawImage(Cont, 0, 0, null); }
public static void main(String[] args) throws IOException { List<Color> colorlist = new ArrayList<Color>(); for (int i = 0; i < 9000; i++) { if (new Random().nextBoolean()) colorlist.add(Color.red); else if (i > 600) colorlist.add(Color.green); else colorlist.add(Color.yellow); } int width = 600; int height = 30; BufferedImage image = null; Graphics2D g2 = null; int step = width / colorlist.size(); ByteArrayOutputStream bs = new ByteArrayOutputStream(); ImageOutputStream imOut = ImageIO.createImageOutputStream(bs); if (step >= 1) { image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); g2 = (Graphics2D) image.getGraphics(); g2.setBackground(Color.WHITE); for (int i = 0; i < colorlist.size(); i++) { g2.setColor(colorlist.get(i)); g2.fillRect(i * step, 0, i * step + step, height); } } else { image = new BufferedImage(colorlist.size(), height, BufferedImage.TYPE_INT_RGB); g2 = (Graphics2D) image.getGraphics(); g2.setBackground(Color.WHITE); for (int i = 0; i < colorlist.size(); i++) { g2.setColor(colorlist.get(i)); g2.drawLine(i, 0, i, height); } } g2.dispose(); Image scaleImage = image.getScaledInstance(width, height, Image.SCALE_SMOOTH); image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); g2 = (Graphics2D) image.getGraphics(); g2.drawImage(scaleImage, 0, 0, null); g2.dispose(); ImageIO.write(image, "GIF", imOut); byte[] contentByte = bs.toByteArray(); FileOutputStream f = new FileOutputStream("d:\\test.gif"); f.write(contentByte); f.flush(); f.close(); bs.close(); imOut.close(); }
public static ScalingReport scale(byte[] fileData, int width, int height) throws ApplicationException { ByteArrayInputStream in = new ByteArrayInputStream(fileData); ScalingReport imagedata = new ScalingReport(); try { BufferedImage img = ImageIO.read(in); if (img.getHeight() > img.getWidth()) { if (img.getHeight() > height) { width = (height * img.getWidth()) / img.getHeight(); Image scaledImage = img.getScaledInstance(width, height, Image.SCALE_SMOOTH); BufferedImage imageBuff = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); imageBuff.getGraphics().drawImage(scaledImage, 0, 0, new Color(0, 0, 0), null); ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ImageIO.write(imageBuff, "jpg", buffer); imagedata.scaledByte = buffer.toByteArray(); imagedata.width = width; imagedata.height = height; } else { imagedata.scaledByte = fileData; imagedata.width = img.getWidth(); imagedata.height = img.getHeight(); } } else { if (img.getWidth() > width) { height = (width * img.getHeight()) / img.getWidth(); Image scaledImage = img.getScaledInstance(width, height, Image.SCALE_SMOOTH); BufferedImage imageBuff = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); imageBuff.getGraphics().drawImage(scaledImage, 0, 0, new Color(0, 0, 0), null); ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ImageIO.write(imageBuff, "jpg", buffer); imagedata.scaledByte = buffer.toByteArray(); imagedata.width = width; imagedata.height = height; } else { imagedata.scaledByte = fileData; imagedata.width = img.getWidth(); imagedata.height = img.getHeight(); } } return imagedata; } catch (IOException e) { throw new ApplicationException("IOException in scale", null); } }
/* * create QR code with overlay */ public static void createQRCode( String qrCodeData, String outputFilePath, String overlayFilePath, String charset, Map<EncodeHintType, ErrorCorrectionLevel> hintMap, int qrCodeheight, int qrCodewidth) throws WriterException, IOException { // create QR code <BufferedImage> QRCodeWriter qrWriter = new QRCodeWriter(); BitMatrix matrix = qrWriter.encode(qrCodeData, BarcodeFormat.QR_CODE, qrCodewidth, qrCodeheight, hintMap); BufferedImage image = MatrixToImageWriter.toBufferedImage(matrix); // read overlay image BufferedImage overlay = ImageIO.read(new File(overlayFilePath)); // Draw the new image int deltaHeight = image.getHeight() - overlay.getHeight(); int deltaWidth = image.getWidth() - overlay.getWidth(); BufferedImage combined = new BufferedImage(qrCodeheight, qrCodewidth, BufferedImage.TYPE_INT_ARGB); Graphics2D g = (Graphics2D) combined.getGraphics(); g.drawImage(image, 0, 0, null); g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f)); g.drawImage(overlay, (int) Math.round(deltaWidth / 2), (int) Math.round(deltaHeight / 2), null); ImageIO.write(combined, "PNG", new File(outputFilePath)); }
public static ImageIcon getBigSystemIcon(Image image) throws Exception { if ((image.getWidth(null) < 20) || (image.getHeight(null) < 20)) { if (image.getWidth(null) > image.getHeight(null)) { width = 24; height = (image.getHeight(null) * 24) / image.getWidth(null); } else { height = 24; width = (image.getWidth(null) * 24) / image.getHeight(null); } } else { return new ImageIcon(image); } dest = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); dest2 = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); g = dest.getGraphics(); g.setColor(Color.white); g.fillRect(0, 0, 22, 22); g.drawImage(image, 0, 0, width, height, null); g.dispose(); sharpenOperator.filter(dest, dest2); return new ImageIcon(dest); }
public Image getScreenshot() { BufferedImage image = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_4BYTE_ABGR); Graphics g = image.getGraphics(); paint(g); g.dispose(); return image; }
/** * 插入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 static Image getScaledInstance(File file) throws Exception { srcBImage = javax.imageio.ImageIO.read(file); if (srcBImage.getWidth() > srcBImage.getHeight()) { width = 100; height = (srcBImage.getHeight() * 100) / srcBImage.getWidth(); } else { height = 100; width = (srcBImage.getWidth() * 100) / srcBImage.getHeight(); } dest = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); dest2 = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); g = dest.getGraphics(); g.setColor(Color.white); g.fillRect(0, 0, 100, 100); g.drawImage(srcBImage, 0, 0, width, height, null); g.dispose(); srcBImage = null; blurOperator.filter(dest, dest2); return dest2; }
// TODO currently allows for collisions if same name & different filetype public void loadImage(String path) { BufferedImage readImage = null; try { readImage = ImageIO.read(new File("images/" + path)); } catch (IOException e) { e.printStackTrace(); } if (readImage != null) { BufferedImage aImages[] = new BufferedImage[8]; BufferedImage image = new BufferedImage( readImage.getWidth(), readImage.getHeight(), BufferedImage.TYPE_INT_ARGB); Graphics g = image.getGraphics(); g.drawImage(readImage, 0, 0, null); for (int i = 0; i < 8; i++) { AffineTransform trans = new AffineTransform(); trans.translate(image.getWidth() / 2, image.getHeight() / 2); trans.rotate(Math.PI * i / 4.0); trans.translate(-image.getWidth() / 2, -image.getHeight() / 2); AffineTransformOp op = new AffineTransformOp(trans, AffineTransformOp.TYPE_BILINEAR); aImages[i] = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB); op.filter(image, aImages[i]); } images.add( new Asset( path.substring(0, path.length() - 4), aImages)); // assumes standard 3 letter postfix } }
/** Return an RGB image that is the expansion of the given grayscale image. */ private static BufferedImage expandGrayThumb(BufferedImage thumb) { BufferedImage ret = new BufferedImage(thumb.getWidth(), thumb.getHeight(), BufferedImage.TYPE_INT_RGB); Graphics g = ret.getGraphics(); g.drawImage(thumb, 0, 0, null); return ret; }
public void drawPixelatedImage(BufferedImage img, int locationX, int locationY) { if (isDrawingPixelatedImages()) { BufferedImage bi = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB); Graphics2D g2 = (Graphics2D) bi.getGraphics(); g2.setColor(Color.WHITE); g2.fillRect(0, 0, img.getWidth(), img.getHeight()); g2.drawImage(img, 0, 0, observer); g2.dispose(); for (int x = 0; x < bi.getWidth(observer); x++) { for (int y = 0; y < bi.getHeight(observer); y++) { int rgb = bi.getRGB(x, y); gc.setColor(new Color(rgb)); gc.setStroke(new BasicStroke(1.0f)); gc.drawLine( locationX + xOffset + x, locationY + yOffset + y, locationX + xOffset + x, locationY + yOffset + y); // gc.drawLine(locationX+xOffset+x, locationY+yOffset+y, // locationX+xOffset+x+1, locationY+yOffset+y); // gc.drawLine(locationX+xOffset+x, locationY+yOffset+y+1, // locationX+xOffset+x+1, locationY+yOffset+y+1); // gc.fillRect(locationX+xOffset+x, locationY+yOffset+y, 1, 1); } } } else { while (!gc.drawImage(img, locationX, locationY, observer)) ; } }
private void btImprimirMouseClicked( java.awt.event.MouseEvent evt) { // GEN-FIRST:event_btImprimirMouseClicked Dimension size = this.getSize(); BufferedImage img = new BufferedImage(size.width, size.height, BufferedImage.TYPE_3BYTE_BGR); Graphics g = img.getGraphics(); this.paint(g); g.dispose(); try { ImageIO.write( img, "png", new File( new JFileChooser().getFileSystemView().getDefaultDirectory().toString() + "/factura" + lbNumeroVenta.getText() + ".png")); JOptionPane.showMessageDialog( rootPane, "La factura ha sido guardada con nombre /factura" + lbNumeroVenta.getText() + ".png en sus documentos"); } catch (IOException ex) { ex.printStackTrace(); } } // GEN-LAST:event_btImprimirMouseClicked
private float getComplexity(BufferedImage img) { // Uses its own resizing method to remove color in the same step BufferedImage sml = new BufferedImage(SIZE, SIZE, BufferedImage.TYPE_BYTE_GRAY); sml.getGraphics().drawImage(img, 0, 0, SIZE, SIZE, null); float ret = 0; int w = sml.getWidth(); int h = sml.getHeight(); Kernel laplace = new Kernel(3, 3, new float[] {1, 1, 1, 1, -8, 1, 1, 1, 1}); ConvolveOp filter = new ConvolveOp(laplace); BufferedImage dest = filter.createCompatibleDestImage(sml, null); filter.filter(sml, dest); WritableRaster data = dest.getRaster(); int[] pixels = data.getPixels(0, 0, w, h, new int[w * h]); int sum = 0; for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { int temp = pixels[i + j * w]; sum += temp; } } ret = (float) sum / (w * h * 256); if (ret < 0.01) { ret = 1; } return ret; }
public void loadTexture(IResourceManager resourceManager) throws IOException { this.deleteGlTexture(); BufferedImage bufferedimage = null; for (String s : this.layeredTextureNames) { IResource iresource = null; try { if (s != null) { iresource = resourceManager.getResource(new ResourceLocation(s)); BufferedImage bufferedimage1 = TextureUtil.readBufferedImage(iresource.getInputStream()); if (bufferedimage == null) { bufferedimage = new BufferedImage(bufferedimage1.getWidth(), bufferedimage1.getHeight(), 2); } bufferedimage.getGraphics().drawImage(bufferedimage1, 0, 0, (ImageObserver) null); } continue; } catch (IOException ioexception) { LOGGER.error((String) "Couldn\'t load layered image", (Throwable) ioexception); } finally { IOUtils.closeQuietly((Closeable) iresource); } return; } TextureUtil.uploadTextureImage(this.getGlTextureId(), bufferedimage); }
/** paints the DrawComponent into the Graphics of the BufferedImage */ protected void paintDrawComponent() { long startTime = 0; if (debugPaint) startTime = System.currentTimeMillis(); if (bufferedImage != null) { Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics(); g2d.setRenderingHints(renderingHintsManager.getRenderingHints()); g2d.setBackground(bgColor); g2d.setPaint(bgColor); g2d.translate(-bufferBounds.x, -bufferBounds.y); g2d.setClip(bufferBounds); g2d.fillRect(bufferBounds.x, bufferBounds.y, bufferBounds.width, bufferBounds.height); if (debugPaint) { drawRealRectangle(g2d); drawBufferRectangle(g2d); drawViewRectangle(g2d); } g2d.scale(scale, scale); DrawComponentPaintable.paintDrawComponent(dc, g2d); } if (debugPaint) { long endTime = System.currentTimeMillis() - startTime; logger.debug("paintDrawComponent took " + endTime + " ms!"); // $NON-NLS-1$ //$NON-NLS-2$ } }
public BufferedImage getBufferedImage() { BufferedImage image = new BufferedImage( Math.max(100, getWidth()), Math.max(100, getHeight()), BufferedImage.TYPE_INT_RGB); paint(image.getGraphics()); return image; }
public void paintComponent(Graphics comp) { if (m_Image == null) { Cursor currentCursor = getCursor(); try { setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); Dimension size = m_WorldMap.getMapSize(); m_Image = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB); Graphics2D g = (Graphics2D) m_Image.getGraphics(); g.setClip(0, 0, size.width, size.height); m_WorldMap.draw(g, 0, 0, getDrawMode()); } finally { setCursor(currentCursor); } } Graphics2D g2D = (Graphics2D) comp; g2D.drawImage(m_Image, null, 0, 0); boolean ShowHexNeighbours = true; if (m_CurrentSegment != -1) m_WorldMap.HighlightSegment(comp, m_CurrentSegment, true); if (m_CurrentSector != -1) m_WorldMap.HighlightSector(g2D, m_CurrentSector, true, ShowHexNeighbours); if (m_CurrentPath != null) m_WorldMap.HighlightPath(g2D, m_CurrentPath, true, ShowHexNeighbours); }
@Override public void paintComponent(Graphics g) { g.setColor(Color.white); g.fillRect(0, 0, getWidth(), getHeight()); int oldHeight = imgHeight; imgHeight = getHeight(); imgHeight -= (imgHeight % av.charHeight); if (imgHeight < 1) { return; } if (oldHeight != imgHeight || image.getWidth(this) != getWidth()) { image = new BufferedImage(getWidth(), imgHeight, BufferedImage.TYPE_INT_RGB); } gg = (Graphics2D) image.getGraphics(); // Fill in the background gg.setColor(Color.white); gg.fillRect(0, 0, getWidth(), imgHeight); drawIds(av.startSeq, av.endSeq); g.drawImage(image, 5, 1, this); }
private BufferedImage toThumbnailImage(BufferedImage contentImage) { if (contentImage != null) { final int thumbnailSize = 64; int width = contentImage.getWidth(); int height = contentImage.getHeight(); int maxSize = Math.max(width, height); if (maxSize <= thumbnailSize) { return contentImage; } else { double scale = (double) thumbnailSize / (double) maxSize; int scaledWidth = (int) (width * scale); int scaledHeight = (int) (height * scale); Image thumbnailImage = contentImage.getScaledInstance(scaledWidth, scaledHeight, Image.SCALE_DEFAULT); if (thumbnailImage instanceof BufferedImage) { return (BufferedImage) thumbnailImage; } else { BufferedImage image = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_RGB); image.getGraphics().drawImage(thumbnailImage, 0, 0, null); return image; } } } return null; }
/** Clear the framebuffer here. */ private void beginFrame() { zBuffer = new float[width][height]; mergedDisplayMatrix = new Matrix4f(viewPortMatrix); mergedDisplayMatrix.mul(sceneManager.getFrustum().getProjectionMatrix()); mergedDisplayMatrix.mul(sceneManager.getCamera().getCameraMatrix()); colorBuffer.getGraphics().clearRect(0, 0, width, height); }
private PageImage scale(double scaleFactor, int scaledDpi) { // check size if (scaleFactor >= 1.0) return this; // scale image BufferedImage scaled = new BufferedImage( ((int) (this.image.getWidth() * scaleFactor)), ((int) (this.image.getHeight() * scaleFactor)), BufferedImage.TYPE_INT_ARGB); Graphics g = scaled.getGraphics(); g.drawImage(this.image, 0, 0, scaled.getWidth(), scaled.getHeight(), null); g.dispose(); // wrap and return scaled image return new PageImage( scaled, this.originalWidth, this.originalHeight, this.originalDpi, scaledDpi, ((int) Math.round(this.leftEdge * scaleFactor)), ((int) Math.round(this.rightEdge * scaleFactor)), ((int) Math.round(this.topEdge * scaleFactor)), ((int) Math.round(this.bottomEdge * scaleFactor)), this.source); }