Java Code Examples for java.awt.Graphics2D#setBackground()

The following examples show how to use java.awt.Graphics2D#setBackground() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
private BufferedImage expandImage(BufferedImage image, int newWidth, int newHeight, Color frameColor) {
    newWidth = Math.max(image.getWidth(), newWidth);
    newHeight = Math.max(image.getHeight(), newHeight);

    int paddingX = (newWidth - image.getWidth()) / 2;
    int paddingY = (newHeight - image.getHeight()) / 2;

    if (paddingX == 0 && paddingY == 0) {
        return image;
    }

    BufferedImage newImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);

    Graphics2D graphics = newImage.createGraphics();
    graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    graphics.setBackground(frameColor);
    graphics.clearRect(0, 0, newWidth, newHeight);
    graphics.drawImage(image, paddingX, paddingY, null);
    graphics.dispose();

    return newImage;
}
 
Example 2
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");
    }
}
 
Example 3
@Override
public void flip(final LWComponentPeer<?, ?> peer, final Image backBuffer,
                 final int x1, final int y1, final int x2, final int y2,
                 final BufferCapabilities.FlipContents flipAction) {
    final Graphics g = peer.getGraphics();
    try {
        g.drawImage(backBuffer, x1, y1, x2, y2, x1, y1, x2, y2, null);
    } finally {
        g.dispose();
    }
    if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) {
        final Graphics2D bg = (Graphics2D) backBuffer.getGraphics();
        try {
            bg.setBackground(peer.getBackground());
            bg.clearRect(0, 0, backBuffer.getWidth(null),
                         backBuffer.getHeight(null));
        } finally {
            bg.dispose();
        }
    }
}
 
Example 4
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");
    }
}
 
Example 5
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");
    }
}
 
Example 6
private BufferedImage buildImage ()
{
    BufferedImage img = (BufferedImage) drawing.createImage(
            width.getValue(),
            height.getValue());

    Graphics2D g2 = img.createGraphics();
    g2.setBackground(Color.white);
    g2.setColor(Color.white);
    g2.fillRect(0, 0, width.getValue(), height.getValue());
    g2.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);

    g2.setColor(Color.black);
    g2.setFont(musicFont);
    g2.drawString(string, xOffset.getValue(), yOffset.getValue());

    FontRenderContext frc = g2.getFontRenderContext();
    TextLayout layout = new TextLayout(string, musicFont, frc);
    Rectangle2D rect = layout.getBounds();
    xSym.setValue(rect.getX());
    ySym.setValue(rect.getY());
    wSym.setValue(rect.getWidth());
    hSym.setValue(rect.getHeight());

    return img;
}
 
Example 7
Source Project: ocular   File: ImageUtils.java    License: GNU General Public License v3.0 5 votes vote down vote up
public static BufferedImage rotateImage(BufferedImage image, double radians) {
	BufferedImage rotatedImage = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
	Graphics2D g2d = rotatedImage.createGraphics();
	g2d.rotate(radians);
	g2d.setBackground(Color.WHITE);
	int maxOfWidthHieght = Math.max(image.getWidth(null), image.getHeight(null));
	g2d.clearRect(-5*maxOfWidthHieght, -5*maxOfWidthHieght, 10*maxOfWidthHieght, 10*maxOfWidthHieght);
	g2d.drawImage(image, 0, 0, Color.WHITE, null);
	g2d.dispose();
	return rotatedImage;
}
 
Example 8
Source Project: JavaWeb   File: AllOpenController.java    License: Apache License 2.0 5 votes vote down vote up
private String drawImg(ByteArrayOutputStream output){
	//final int verifyCodeLength = 10;
	final int verifyCodeLength = 4;
	String code = getVerifyCode(verifyCodeLength);
	//int width = 125;
	int width = 70;
	int height = 25;
	BufferedImage bi = new BufferedImage(width,height,BufferedImage.TYPE_3BYTE_BGR);
	Font font = new Font("Times New Roman",Font.PLAIN,20);
	Graphics2D g = bi.createGraphics();
	g.setFont(font);
	g.setColor(new Color(66,2,82));
	g.setBackground(new Color(226,226,240));
	g.clearRect(0, 0, width, height);
	FontRenderContext context = g.getFontRenderContext();
	Rectangle2D bounds = font.getStringBounds(code, context);
	double x = (width - bounds.getWidth()) / 2;
	double y = (height - bounds.getHeight()) / 2;
	double ascent = bounds.getY();
	double baseY = y - ascent;
	g.drawString(code, (int)x, (int)baseY);
	g.dispose();
	try {
		ImageIO.write(bi, "jpg", output);
	} catch (IOException e) {
		//do nothing
	}
	return code;
}
 
Example 9
@Override
public Graphics getGraphics() {
    if (bbImage == null) return null;

    Graphics2D g = bbImage.createGraphics();
    g.setBackground(getBackground());
    g.setColor(getForeground());
    g.setFont(getFont());
    g.scale(scaleFactor, scaleFactor);
    return g;
}
 
Example 10
Source Project: rtree-3d   File: Visualizer.java    License: Apache License 2.0 5 votes vote down vote up
public BufferedImage createImage() {
    final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
    final Graphics2D g = (Graphics2D) image.getGraphics();
    g.setBackground(Color.white);
    g.clearRect(0, 0, width, height);
    g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.75f));

    if (tree.root().isPresent()) {
        final List<RectangleDepth> nodeDepths = getNodeDepthsSortedByDepth(tree.root().get());
        drawNode(g, nodeDepths);
    }
    return image;
}
 
Example 11
@Override
public Graphics getGraphics() {
    if (bbImage == null) return null;

    Graphics2D g = bbImage.createGraphics();
    g.setBackground(getBackground());
    g.setColor(getForeground());
    g.setFont(getFont());
    g.scale(scaleFactor, scaleFactor);
    return g;
}
 
Example 12
@Override
public PaintContext createContext(ColorModel cm,
                                  Rectangle deviceBounds,
                                  Rectangle2D userBounds,
                                  AffineTransform at,
                                  RenderingHints hints) {

    // Fill bufferedImage using
    final Graphics2D g2d = (Graphics2D) getImage().getGraphics();
    try {
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setBackground(Color.PINK);
        g2d.clearRect(0, 0, size, size);

        g2d.setColor(Color.BLUE);
        g2d.drawRect(0, 0, size, size);

        g2d.fillOval(size / 10, size / 10,
                     size * 8 / 10, size * 8 / 10);

    } finally {
        g2d.dispose();
    }

    return super.createContext(cm, deviceBounds, userBounds, at, hints);
}
 
Example 13
@Override
public PaintContext createContext(ColorModel cm,
                                  Rectangle deviceBounds,
                                  Rectangle2D userBounds,
                                  AffineTransform at,
                                  RenderingHints hints) {

    // Fill bufferedImage using
    final Graphics2D g2d = (Graphics2D) getImage().getGraphics();
    try {
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setBackground(Color.PINK);
        g2d.clearRect(0, 0, size, size);

        g2d.setColor(Color.BLUE);
        g2d.drawRect(0, 0, size, size);

        g2d.fillOval(size / 10, size / 10,
                     size * 8 / 10, size * 8 / 10);

    } finally {
        g2d.dispose();
    }

    return super.createContext(cm, deviceBounds, userBounds, at, hints);
}
 
Example 14
Source Project: phoebus   File: Plot.java    License: Eclipse Public License 1.0 4 votes vote down vote up
/** Draw visual feedback (rubber band rectangle etc.)
 *  for current mouse mode
 *  @param gc GC
 */
@Override
protected void drawMouseModeFeedback(final Graphics2D gc)
{   // Safe copy, then check null (== isPresent())
    final Point2D current = mouse_current.orElse(null);
    if (current == null)
        return;

    // Compute values at cursor
    final int x = (int) current.getX();
    final XTYPE location = x_axis.getValue(x);
    List<CursorMarker> markers;
    try
    {
        markers = CursorMarker.compute(this, x, location);
        fireCursorsChanged();
    }
    catch (Exception ex)
    {
        logger.log(Level.WARNING, "Cannot compute cursor markers", ex);
        markers = Collections.emptyList();
    }

    final Point2D start = mouse_start.orElse(null);
    final Rectangle plot_bounds = plot_area.getBounds();

    if (mouse_mode == MouseMode.PAN_X  ||  mouse_mode == MouseMode.PAN_Y || mouse_mode == MouseMode.PAN_PLOT ||
        (mouse_annotation != null  &&  start != null))
    {
        // NOP, minimize additional UI thread drawing to allow better 'pan' updates
        //      and also hide the crosshair when moving an annotation
    }
    else if (show_crosshair  &&  plot_bounds.contains(current.getX(), current.getY()))
    {   // Cross-hair Cursor
        gc.setStroke(MOUSE_FEEDBACK_BACK);
        gc.setColor(background);
        gc.drawLine(plot_bounds.x, (int)current.getY(), plot_bounds.x + plot_bounds.width, (int)current.getY());
        gc.drawLine((int)current.getX(), plot_bounds.y, (int)current.getX(), plot_bounds.y + plot_bounds.height);
        gc.setStroke(MOUSE_FEEDBACK_FRONT);
        gc.setColor(GraphicsUtils.convert(foreground));
        gc.drawLine(plot_bounds.x, (int)current.getY(), plot_bounds.x + plot_bounds.width, (int)current.getY());
        gc.drawLine((int)current.getX(), plot_bounds.y, (int)current.getX(), plot_bounds.y + plot_bounds.height);
        // Corresponding axis ticks
        gc.setBackground(background);
        x_axis.drawTickLabel(gc, x_axis.getValue((int)current.getX()));
        for (YAxisImpl<XTYPE> axis : y_axes)
            axis.drawTickLabel(gc, axis.getValue((int)current.getY()));
        // Trace markers
        CursorMarker.drawMarkers(gc, markers, area);
    }

    if (mouse_mode == MouseMode.ZOOM_IN_X  &&  start != null)
        drawZoomXMouseFeedback(gc, plot_bounds, start, current);
    else if (mouse_mode == MouseMode.ZOOM_IN_Y  &&  start != null)
        drawZoomYMouseFeedback(gc, plot_bounds, start, current);
    else if (mouse_mode == MouseMode.ZOOM_IN_PLOT  &&  start != null)
        drawZoomMouseFeedback(gc, plot_bounds, start, current);
}
 
Example 15
@Override
public void paintComponent(Graphics g) {
	Graphics2D g2 = (Graphics2D) g;
	// FontMetrics fM = pickFont(g2, tree, space);

	double width = width(tree, myFont);
	double height = height(tree, myFont);
	preferredX = (int) width;
	preferredY = (int) height;
	setSize(new Dimension(preferredX, preferredY));
	setPreferredSize(new Dimension(preferredX, preferredY));
	setMaximumSize(new Dimension(preferredX, preferredY));
	setMinimumSize(new Dimension(preferredX, preferredY));
	// setSize(new Dimension((int)Math.round(width),
	// (int)Math.round(height)));
	g2.setFont(myFont.getFont());

	Dimension space = getSize();
	double startX = 0.0;
	double startY = 0.0;
	if (HORIZONTAL_ALIGN == SwingConstants.CENTER) {
		startX = (space.getWidth() - width) / 2.0;
	}
	if (HORIZONTAL_ALIGN == SwingConstants.RIGHT) {
		startX = space.getWidth() - width;
	}
	if (VERTICAL_ALIGN == SwingConstants.CENTER) {
		startY = (space.getHeight() - height) / 2.0;
	}
	if (VERTICAL_ALIGN == SwingConstants.BOTTOM) {
		startY = space.getHeight() - height;
	}
	super.paintComponent(g);

	g2.setBackground(Color.white);
	g2.clearRect(0, 0, space.width, space.height);

	g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
			1.0f));
	g2.setPaint(Color.black);

	paintTree(tree, new Point2D.Double(startX, startY), g2, myFont);
}
 
Example 16
public static void main(String argv[]) {
    Locale.setDefault(Locale.US);

    // initialize j.u.l Looger:
    final Logger log = Logger.getLogger("sun.java2d.marlin");
    log.addHandler(new Handler() {
        @Override
        public void publish(LogRecord record) {
            Throwable th = record.getThrown();
            // detect any Throwable:
            if (th != null) {
                System.out.println("Test failed:\n" + record.getMessage());
                th.printStackTrace(System.out);

                throw new RuntimeException("Test failed: ", th);
            }
        }

        @Override
        public void flush() {
        }

        @Override
        public void close() throws SecurityException {
        }
    });

    // enable Marlin logging & internal checks:
    System.setProperty("sun.java2d.renderer.log", "true");
    System.setProperty("sun.java2d.renderer.useLogger", "true");
    System.setProperty("sun.java2d.renderer.doChecks", "true");

    final int width = 400;
    final int height = 400;

    final BufferedImage image = new BufferedImage(width, height,
            BufferedImage.TYPE_INT_ARGB);

    final Graphics2D g2d = (Graphics2D) image.getGraphics();
    try {
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);

        g2d.setBackground(Color.WHITE);
        g2d.clearRect(0, 0, width, height);

        final Path2D.Double path = new Path2D.Double();
        path.moveTo(30, 30);
        path.lineTo(100, 100);

        for (int i = 0; i < 20000; i++) {
            path.lineTo(110 + 0.01 * i, 110);
            path.lineTo(111 + 0.01 * i, 100);
        }

        path.lineTo(NaN, 200);
        path.lineTo(200, 200);
        path.lineTo(200, NaN);
        path.lineTo(300, 300);
        path.lineTo(NaN, NaN);
        path.lineTo(100, 100);
        path.closePath();

        final Path2D.Double path2 = new Path2D.Double();
        path2.moveTo(0,0);
        path2.lineTo(width,height);
        path2.lineTo(10, 10);
        path2.closePath();

        for (int i = 0; i < 1; i++) {
            final long start = System.nanoTime();
            g2d.setColor(Color.BLUE);
            g2d.fill(path);

            g2d.fill(path2);

            final long time = System.nanoTime() - start;
            System.out.println("paint: duration= " + (1e-6 * time) + " ms.");
        }

        if (SAVE_IMAGE) {
            try {
                final File file = new File("CrashNaNTest.png");
                System.out.println("Writing file: "
                        + file.getAbsolutePath());
                ImageIO.write(image, "PNG", file);
            } catch (IOException ex) {
                System.out.println("Writing file failure:");
                ex.printStackTrace();
            }
        }
    } finally {
        g2d.dispose();
    }
}
 
Example 17
private static void test(final float lineStroke,
                             final boolean useDashes,
                             final float dashMinLen)
        throws ArrayIndexOutOfBoundsException
    {
        System.out.println("---\n" + "test: "
            + "lineStroke=" + lineStroke
            + ", useDashes=" + useDashes
            +", dashMinLen=" + dashMinLen
        );

        final BasicStroke stroke = createStroke(lineStroke, useDashes, dashMinLen);

        // TODO: test Dasher.firstSegmentsBuffer resizing ?
// array.dasher.firstSegmentsBuffer.d_float[2] sum: 6 avg: 3.0 [3 | 3]
        /*
         // Marlin growable arrays:
         = new StatLong("array.dasher.firstSegmentsBuffer.d_float");
         = new StatLong("array.stroker.polystack.curves.d_float");
         = new StatLong("array.stroker.polystack.curveTypes.d_byte");
         = new StatLong("array.marlincache.rowAAChunk.d_byte");
         = new StatLong("array.marlincache.touchedTile.int");
         = new StatLong("array.renderer.alphaline.int");
         = new StatLong("array.renderer.crossings.int");
         = new StatLong("array.renderer.aux_crossings.int");
         = new StatLong("array.renderer.edgeBuckets.int");
         = new StatLong("array.renderer.edgeBucketCounts.int");
         = new StatLong("array.renderer.edgePtrs.int");
         = new StatLong("array.renderer.aux_edgePtrs.int");
         */
        // size > 8192 (exceed both tile and buckets arrays)
        final int size = 9000;
        System.out.println("image size = " + size);

        final BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);

        final Graphics2D g2d = (Graphics2D) image.getGraphics();
        try {
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

            g2d.setClip(0, 0, size, size);
            g2d.setBackground(Color.WHITE);
            g2d.clearRect(0, 0, size, size);

            g2d.setStroke(stroke);
            g2d.setColor(Color.BLACK);

            final long start = System.nanoTime();

            paint(g2d, size - 10f);

            final long time = System.nanoTime() - start;

            System.out.println("paint: duration= " + (1e-6 * time) + " ms.");

            if (SAVE_IMAGE) {
                try {
                    final File file = new File("CrashTest-dash-" + useDashes + ".bmp");

                    System.out.println("Writing file: " + file.getAbsolutePath());
                    ImageIO.write(image, "BMP", file);
                } catch (IOException ex) {
                    System.out.println("Writing file failure:");
                    ex.printStackTrace();
                }
            }
        } finally {
            g2d.dispose();
        }
    }
 
Example 18
Source Project: swingsane   File: DeskewTransform.java    License: Apache License 2.0 4 votes vote down vote up
public final BufferedImage rotate(BufferedImage image, double angle, int cx, int cy) {

    int width = image.getWidth(null);
    int height = image.getHeight(null);

    int minX, minY, maxX, maxY;
    minX = minY = maxX = maxY = 0;

    int[] corners = { 0, 0, width, 0, width, height, 0, height };

    double theta = Math.toRadians(angle);
    for (int i = 0; i < corners.length; i += 2) {
      int x = (int) (((Math.cos(theta) * (corners[i] - cx)) - (Math.sin(theta) * (corners[i + 1] - cy))) + cx);
      int y = (int) ((Math.sin(theta) * (corners[i] - cx))
          + (Math.cos(theta) * (corners[i + 1] - cy)) + cy);

      if (x > maxX) {
        maxX = x;
      }

      if (x < minX) {
        minX = x;
      }

      if (y > maxY) {
        maxY = y;
      }

      if (y < minY) {
        minY = y;
      }

    }

    cx = (cx - minX);
    cy = (cy - minY);

    BufferedImage bufferedImage = new BufferedImage((maxX - minX), (maxY - minY), image.getType());
    Graphics2D graphics2d = bufferedImage.createGraphics();
    graphics2d.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
        RenderingHints.VALUE_FRACTIONALMETRICS_ON);
    graphics2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);

    graphics2d.setBackground(Color.white);
    graphics2d.fillRect(0, 0, bufferedImage.getWidth(), bufferedImage.getHeight());

    AffineTransform at = new AffineTransform();
    at.rotate(theta, cx, cy);

    graphics2d.setTransform(at);
    graphics2d.drawImage(image, -minX, -minY, null);
    graphics2d.dispose();

    return bufferedImage;

  }
 
Example 19
Source Project: render   File: Renderer.java    License: GNU General Public License v2.0 4 votes vote down vote up
/**
 * Renders to the specified image.
 *
 * @param  converter    converts to the desired output type.
 * @param  targetImage  target for rendered result.
 *
 * @throws IllegalArgumentException
 *   if rendering fails for any reason.
 */
private void renderToBufferedImage(final ProcessorWithMasksConverter converter,
                                   final BufferedImage targetImage)
        throws IllegalArgumentException {

    final int numberOfTileSpecs = renderParameters.numberOfTileSpecs();

    LOG.debug("renderToBufferedImage: entry, processing {} tile specifications, numberOfThreads={}",
              numberOfTileSpecs, renderParameters.getNumberOfThreads());

    final long tileLoopStart = System.currentTimeMillis();

    final ImageProcessorWithMasks worldTarget = renderImageProcessorWithMasks();

    final long drawImageStart = System.currentTimeMillis();

    if (worldTarget != null) {

        final Graphics2D targetGraphics = targetImage.createGraphics();

        // TODO: see if there is a more efficient way to do the background fill and avoid redraw of image below
        final Integer backgroundRGBColor = renderParameters.getBackgroundRGBColor();
        if (backgroundRGBColor != null) {

            targetGraphics.setBackground(new Color(backgroundRGBColor));
            targetGraphics.clearRect(0, 0, targetImage.getWidth(), targetImage.getHeight());

        } else if (renderParameters.isFillWithNoise()) {

            final ByteProcessor ip = new ByteProcessor(targetImage.getWidth(), targetImage.getHeight());
            mpicbg.ij.util.Util.fillWithNoise(ip);
            targetGraphics.drawImage(ip.createImage(), 0, 0, null);

        }

        final BufferedImage image = converter.convertProcessorWithMasksToImage(renderParameters, worldTarget);
        targetGraphics.drawImage(image, 0, 0, null);

        if (renderParameters.isAddWarpFieldDebugOverlay()) {
            WarpFieldDebugRenderer.render(renderParameters,
                                          targetGraphics,
                                          targetImage.getWidth(),
                                          targetImage.getHeight());
        }

        targetGraphics.dispose();

    }

    final long drawImageStop = System.currentTimeMillis();

    LOG.debug("renderToBufferedImage: exit, {} tiles processed in {} milliseconds, draw image:{}",
              numberOfTileSpecs,
              System.currentTimeMillis() - tileLoopStart,
              drawImageStop - drawImageStart);
}
 
Example 20
Source Project: sc2gears   File: View.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public void paint( final Graphics g ) {
	final Graphics2D g2 = (Graphics2D) g;
	g2.setBackground( Color.BLACK );
	g2.clearRect( 0, 0, Consts.WIDTH, Consts.HEIGHT );
	g2.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
	
	model = model_;
	if ( model == null ) {
		paintInfo( g2 );
	}
	else {
		// Clone the model so we can concurrently paint it and have the controller modify it
		model = model_.clone();
		final boolean colorBind = Settings.getBoolean( Settings.KEY_MOUSE_PRACTICE_COLOR_BLIND );
		
		// Draw objects of the model
		for ( final Disc disc : model.discList ) {
			if ( rules.paintMaxDiscOutline ) {
   				g2.setColor( Color.GRAY );
   				g2.drawOval( (int) ( disc.x - rules.maxDiscRadius ), (int) ( disc.y - rules.maxDiscRadius ), ( rules.maxDiscRadius << 1 ) + 1, ( rules.maxDiscRadius << 1 ) + 1 );
			}
			
			g2.setColor( disc.friendly ? PlayerColor.GREEN.color : PlayerColor.RED.color );
			if ( disc.friendly || !colorBind )
				g2.fillOval( (int) ( disc.x - disc.radius ), (int) ( disc.y - disc.radius ), (int) ( disc.radius*2 ) + 1, (int) ( disc.radius*2 ) + 1 );
			else {
				final Stroke storedStroke = g2.getStroke();
				g2.setStroke( DOUBLE_STROKE );
				g2.drawOval( (int) ( disc.x - disc.radius ), (int) ( disc.y - disc.radius ), (int) ( disc.radius*2 ) + 1, (int) ( disc.radius*2 ) + 1 );
				g2.setStroke( storedStroke );
			}
			
			if ( rules.paintDiscCenterCross && disc.radius > 1 ) {
   				g2.setColor( Color.WHITE );
   				g2.drawLine( (int) ( disc.x - disc.radius/2 ), (int) disc.y, (int) ( disc.x + disc.radius/2 ), (int) disc.y );
   				g2.drawLine( (int) disc.x, (int) ( disc.y - disc.radius/2 ), (int) disc.x, (int) ( disc.y + disc.radius/2 ) );
			}
		}
		
		final FontMetrics fontMetrics = g2.getFontMetrics();
		final int shiftY = fontMetrics.getAscent() >> 1;
		for ( final FloatingText floatingText : model.floatingTextList ) {
			g2.setColor( floatingText.color );
			g2.drawString( floatingText.text, floatingText.x - ( fontMetrics.stringWidth( floatingText.text ) >> 1 ), floatingText.y + shiftY );
		}
		
		// Draw texts
		paintTexts( g2 );
	}
}