Example usage for java.awt RenderingHints VALUE_ANTIALIAS_ON

List of usage examples for java.awt RenderingHints VALUE_ANTIALIAS_ON

Introduction

In this page you can find the example usage for java.awt RenderingHints VALUE_ANTIALIAS_ON.

Prototype

Object VALUE_ANTIALIAS_ON

To view the source code for java.awt RenderingHints VALUE_ANTIALIAS_ON.

Click Source Link

Document

Antialiasing hint value -- rendering is done with antialiasing.

Usage

From source file:net.technicpack.launcher.lang.ResourceLoader.java

public BufferedImage getCircleClippedImage(String imageName) {
    BufferedImage contentImage = getImage(imageName);

    // copy the picture to an image with transparency capabilities
    BufferedImage outputImage = new BufferedImage(contentImage.getWidth(), contentImage.getHeight(),
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2 = (Graphics2D) outputImage.getGraphics();
    g2.drawImage(contentImage, 0, 0, null);

    // Create the area around the circle to cut out
    Area cutOutArea = new Area(new Rectangle(0, 0, outputImage.getWidth(), outputImage.getHeight()));

    int diameter = (outputImage.getWidth() < outputImage.getHeight()) ? outputImage.getWidth()
            : outputImage.getHeight();/*from w ww .  j  a v  a2 s.  c om*/
    cutOutArea.subtract(new Area(new Ellipse2D.Float((outputImage.getWidth() - diameter) / 2,
            (outputImage.getHeight() - diameter) / 2, diameter, diameter)));

    // Set the fill color to an opaque color
    g2.setColor(Color.WHITE);
    // Set the composite to clear pixels
    g2.setComposite(AlphaComposite.Clear);
    // Turn on antialiasing
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    // Clear the cut out area
    g2.fill(cutOutArea);

    // dispose of the graphics object
    g2.dispose();

    return outputImage;
}

From source file:edu.ku.brc.ui.GraphicsUtils.java

/**
 * Modifes the given {@link Graphics} object to enable anti-aliased
 * drawing./*from   w  w  w.j av a 2  s . com*/
 *
 * @param g a {@link Graphics} object
 */
public static void turnOnAntialiasedDrawing(Graphics g) {
    if (g instanceof Graphics2D) {
        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    }
}

From source file:com.qumasoft.guitools.compare.ContentRow.java

@Override
public void paint(Graphics g) {
    if ((getRowType() == ROWTYPE_REPLACE) && rowHadAnnotations) {
        Graphics2D g2 = (Graphics2D) g;

        String s = getText();/* w  w w  .  j av  a  2  s  .  co  m*/

        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        if (s.length() > 0) {
            int index = 0;
            AttributedString attributedString = new AttributedString(s, getFont().getAttributes());
            try {
                for (byte rType : fileACharacterTypeArray) {
                    switch (rType) {
                    case ContentRow.ROWTYPE_DELETE:
                        attributedString.addAttribute(TextAttribute.STRIKETHROUGH, null, index, index + 1);
                        break;
                    case ContentRow.ROWTYPE_REPLACE:
                        attributedString.addAttribute(TextAttribute.BACKGROUND,
                                ColorManager.getReplaceCompareHiliteBackgroundColor(), index, index + 1);
                        break;
                    default:
                        break;
                    }
                    index++;
                }
                g2.drawString(attributedString.getIterator(), 0, getFont().getSize());
            } catch (java.lang.IllegalArgumentException e) {
                LOGGER.log(Level.WARNING, "bad replace indexes. begin index: [" + index + "] end index: ["
                        + index + "]. String length: [" + s.length() + "]");
            }
        } else {
            super.paint(g);
        }
    } else {
        super.paint(g);
    }
}

From source file:StrokeChooserPanel.java

/**
 * Draws a line using the sample stroke.
 *
 * @param g  the graphics device./* w  w w  .  j  a  v  a 2s  . c  om*/
 */
public void paintComponent(final Graphics g) {

    final Graphics2D g2 = (Graphics2D) g;
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    final Dimension size = getSize();
    final Insets insets = getInsets();
    final double xx = insets.left;
    final double yy = insets.top;
    final double ww = size.getWidth() - insets.left - insets.right;
    final double hh = size.getHeight() - insets.top - insets.bottom;

    // calculate point one
    final Point2D one = new Point2D.Double(xx + 6, yy + hh / 2);
    // calculate point two
    final Point2D two = new Point2D.Double(xx + ww - 6, yy + hh / 2);
    // draw a circle at point one
    final Ellipse2D circle1 = new Ellipse2D.Double(one.getX() - 5, one.getY() - 5, 10, 10);
    final Ellipse2D circle2 = new Ellipse2D.Double(two.getX() - 6, two.getY() - 5, 10, 10);

    // draw a circle at point two
    g2.draw(circle1);
    g2.fill(circle1);
    g2.draw(circle2);
    g2.fill(circle2);

    // draw a line connecting the points
    final Line2D line = new Line2D.Double(one, two);
    if (this.stroke != null) {
        g2.setStroke(this.stroke);
        g2.draw(line);
    }

}

From source file:ddf.catalog.transformer.input.pptx.PptxInputTransformer.java

/**
 * If the slide show doesn't contain any slides, then return null. Otherwise, return jpeg
 * image data of the first slide in the deck.
 *
 * @param slideShow//from  ww w  .j a v a2  s .com
 * @return jpeg thumbnail or null if thumbnail can't be created
 * @throws IOException
 */
private byte[] generatePptxThumbnail(XMLSlideShow slideShow) throws IOException {

    if (slideShow.getSlides().isEmpty()) {
        LOGGER.info("the powerpoint file does not contain any slides, skipping thumbnail generation");
        return null;
    }

    Dimension pgsize = slideShow.getPageSize();

    int largestDimension = (int) Math.max(pgsize.getHeight(), pgsize.getWidth());
    float scalingFactor = IMAGE_HEIGHTWIDTH / largestDimension;
    int scaledHeight = (int) (pgsize.getHeight() * scalingFactor);
    int scaledWidth = (int) (pgsize.getWidth() * scalingFactor);
    BufferedImage img = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_RGB);

    Graphics2D graphics = img.createGraphics();

    try {
        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        graphics.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                RenderingHints.VALUE_FRACTIONALMETRICS_ON);

        graphics.scale(scalingFactor, scalingFactor);

        slideShow.getSlides().get(0).draw(graphics);

        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            ImageIOUtil.writeImage(img, FORMAT_NAME, outputStream, RESOLUTION_DPI, IMAGE_QUALITY);
            return outputStream.toByteArray();
        }
    } catch (RuntimeException e) {
        if (e.getCause() instanceof javax.imageio.IIOException) {
            LOGGER.warn("unable to generate thumbnail for PPTX file", e);
        } else {
            throw e;
        }
    } finally {
        graphics.dispose();
    }

    return null;
}

From source file:coolmap.canvas.datarenderer.renderer.impl.NumberToBoxPlot.java

private void updateLegend() {

    int width = DEFAULT_LEGEND_WIDTH;
    int height = DEFAULT_LEGENT_HEIGHT;
    legend = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice()
            .getDefaultConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
    Graphics2D g = (Graphics2D) legend.createGraphics();
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    g.setPaint(UI.colorBlack2);//w  ww. ja v a 2  s.  c o m
    g.fillRoundRect(0, 0, width, height - 12, 5, 5);

    g.setColor(barColorBelow);
    int boxNum = 10;
    g.setStroke(UI.stroke1_5);

    double value;
    for (int i = 0; i < boxNum; i++) {
        value = _minValue + (_maxValue - _minValue) / boxNum * i;

        if (value > disectBound) {
            g.setColor(barColorNormal);
        }

        int h = (height - 12) / boxNum * i;
        g.drawLine(i * width / boxNum, height - 12 - h, (i + 1) * width / boxNum, height - 12 - h);

    }

    g.setColor(Color.BLACK);
    g.setFont(UI.fontMono.deriveFont(10f));
    DecimalFormat format = new DecimalFormat("#.##");
    g.drawString(format.format(_minValue), 2, 23);

    g.setColor(Color.BLACK);
    String maxString = format.format(_maxValue);
    int swidth = g.getFontMetrics().stringWidth(maxString);
    g.drawString(maxString, width - 2 - swidth, 23);
    g.dispose();
}

From source file:org.earthtime.UPb_Redux.dateInterpretation.WeightedMeanGraphPanel.java

/**
 *
 * @param g2d/*from  w w  w.j  av  a2  s. c o  m*/
 */
public void paint(Graphics2D g2d) {

    // setup painting parameters
    String fractionSortOrder = "name"; //random, weight, date
    if (getWeightedMeanOptions().containsKey("fractionSortOrder")) {
        fractionSortOrder = getWeightedMeanOptions().get("fractionSortOrder");
    }

    double rangeX = (getMaxX_Display() - getMinX_Display());
    double rangeY = (getMaxY_Display() - getMinY_Display());

    g2d.setClip(getLeftMargin(), getTopMargin(), getGraphWidth(), getGraphHeight());
    RenderingHints rh = g2d.getRenderingHints();
    rh.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g2d.setRenderingHints(rh);

    // walk the sampleDateInterpretations and produce graphs
    g2d.setPaint(Color.BLACK);
    g2d.setStroke(new BasicStroke(2.0f));
    g2d.setFont(new Font("SansSerif", Font.BOLD, 10));

    double barWidth = 15.0;
    double barGap = 10.0;
    double startSamX = 10.0;
    double saveStartSamX = 0.0;
    double samSpace = 3.0;

    for (int i = 0; i < selectedSampleDateModels.length; i++) {
        for (int j = 1; j < 9; j++) {
            if (selectedSampleDateModels[i][j] instanceof SampleDateModel) {

                final SampleDateModel SAM = ((SampleDateModel) selectedSampleDateModels[i][j]);
                double wMean = SAM.getValue().movePointLeft(6).doubleValue();
                double wMeanOneSigma = SAM.getOneSigmaAbs().movePointLeft(6).doubleValue();

                Path2D mean = new Path2D.Double(Path2D.WIND_NON_ZERO);

                // july 2008
                // modified to show de-selected fractions as gray
                // this means a new special list of fractionIDs is created fromall non-rejected fractions
                // and each instance is tested for being included
                // should eventually refactor
                Vector<String> allFIDs = new Vector<String>();
                for (String f : ((UPbReduxAliquot) SAM.getAliquot()).getAliquotFractionIDs()) {
                    // test added for Sample-based wm
                    if (SAM.fractionDateIsPositive(//
                            ((UPbReduxAliquot) SAM.getAliquot()).getAliquotFractionByName(f))) {
                        allFIDs.add(f);
                    }
                }

                final int iFinal = i;
                if (fractionSortOrder.equalsIgnoreCase("weight")) {
                    Collections.sort(allFIDs, new Comparator<String>() {

                        public int compare(String fID1, String fID2) {
                            double invertOneSigmaF1 = //
                                    1.0 //
                                            / ((UPbReduxAliquot) selectedSampleDateModels[iFinal][0])//
                                                    .getAliquotFractionByName(fID1)//
                                                    .getRadiogenicIsotopeDateByName(SAM.getDateName())//
                                                    .getOneSigmaAbs().movePointLeft(6).doubleValue();
                            double invertOneSigmaF2 = //
                                    1.0 //
                                            / ((UPbReduxAliquot) selectedSampleDateModels[iFinal][0])//
                                                    .getAliquotFractionByName(fID2)//
                                                    .getRadiogenicIsotopeDateByName(SAM.getDateName())//
                                                    .getOneSigmaAbs().movePointLeft(6).doubleValue();

                            return Double.compare(invertOneSigmaF2, invertOneSigmaF1);
                        }
                    });
                } else if (fractionSortOrder.equalsIgnoreCase("date")) {
                    Collections.sort(allFIDs, new Comparator<String>() {

                        public int compare(String fID1, String fID2) {
                            double dateF1 = //
                                    ((UPbReduxAliquot) selectedSampleDateModels[iFinal][0])//
                                            .getAliquotFractionByName(fID1)//
                                            .getRadiogenicIsotopeDateByName(SAM.getDateName())//
                                            .getValue().doubleValue();
                            double dateF2 = //
                                    ((UPbReduxAliquot) selectedSampleDateModels[iFinal][0])//
                                            .getAliquotFractionByName(fID2)//
                                            .getRadiogenicIsotopeDateByName(SAM.getDateName())//
                                            .getValue().doubleValue();

                            return Double.compare(dateF1, dateF2);
                        }
                    });
                } else if ( /* ! isInRandomMode() &&*/fractionSortOrder.equalsIgnoreCase("random")) {
                    Collections.shuffle(allFIDs, new Random());
                } else if (fractionSortOrder.equalsIgnoreCase("name")) {
                    // default to alphabetic by name
                    //Collections.sort(allFIDs);
                    // april 2010 give same lexigraphic ordering that UPbFractions get
                    Collections.sort(allFIDs, new IntuitiveStringComparator<String>());
                } else {
                    // do nothing
                }

                double actualWidthX = (allFIDs.size()) * (barWidth + barGap);//; + barGap;

                // plot 2-sigma of mean
                mean.moveTo((float) mapX(startSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean + 2.0 * wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean + 2.0 * wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean - 2.0 * wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean - 2.0 * wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.closePath();

                g2d.setColor(ReduxConstants.mySampleYellowColor);
                g2d.fill(mean);
                g2d.setPaint(Color.BLACK);

                // plot 1-sigma of mean
                mean.reset();
                mean.moveTo((float) mapX(startSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean + wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean + wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean - wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean - wMeanOneSigma, getMaxY_Display(), rangeY, graphHeight));
                mean.closePath();

                g2d.setColor(ReduxConstants.ColorOfRedux);
                g2d.fill(mean);
                g2d.setPaint(Color.BLACK);

                // plot mean
                mean.reset();
                mean.moveTo((float) mapX(startSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean, getMaxY_Display(), rangeY, graphHeight));
                mean.lineTo((float) mapX(startSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(wMean, getMaxY_Display(), rangeY, graphHeight));
                g2d.setStroke(new BasicStroke(1.0f));
                g2d.draw(mean);
                g2d.setStroke(new BasicStroke(2.0f));

                saveStartSamX = startSamX;

                // plot fraction bars
                double minPoint = 5000.0;
                double maxWeight = 0.0;
                double totalWeight = 0.0;

                int barNum = 0;

                for (String fID : allFIDs) {
                    // the dateModel has an associated aliquot, but in sample mode, it is a
                    // standin aliquot for the sample.  to get the aliquot number for
                    // use in coloring fractions, we need to query the fraction itself
                    String aliquotName = sample.getAliquotNameByFractionID(fID);

                    Color includedFillColor = new Color(0, 0, 0);
                    if (sample.getSampleDateInterpretationGUISettings().getAliquotOptions().get(aliquotName)
                            .containsKey("includedFillColor")) {
                        String[] temp = //
                                sample.getSampleDateInterpretationGUISettings().getAliquotOptions()
                                        .get(aliquotName).get("includedFillColor").split(",");
                        includedFillColor = buildRGBColor(temp);
                    }

                    Fraction f = ((UPbReduxAliquot) selectedSampleDateModels[i][0])
                            .getAliquotFractionByName(fID);

                    double date = f.//((UPbReduxAliquot) selectedSampleDateModels[i][0]).getAliquotFractionByName(fID).//
                            getRadiogenicIsotopeDateByName(SAM.getDateName()).getValue().movePointLeft(6)
                            .doubleValue();
                    double twoSigma = f.//((UPbReduxAliquot) selectedSampleDateModels[i][0]).getAliquotFractionByName(fID).//
                            getRadiogenicIsotopeDateByName(SAM.getDateName()).getTwoSigmaAbs().movePointLeft(6)
                            .doubleValue();

                    if ((date - twoSigma) < minPoint) {
                        minPoint = (date - twoSigma);
                    }

                    double invertedOneSigma = //
                            1.0 //
                                    / f.//((UPbReduxAliquot) selectedSampleDateModels[i][0]).getAliquotFractionByName(fID).//
                                            getRadiogenicIsotopeDateByName(SAM.getDateName()).getOneSigmaAbs()
                                            .movePointLeft(6).doubleValue();

                    if (invertedOneSigma > maxWeight) {
                        maxWeight = invertedOneSigma;
                    }

                    Path2D bar = new Path2D.Double(Path2D.WIND_NON_ZERO);
                    bar.moveTo(
                            (float) mapX(saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)),
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date + twoSigma, getMaxY_Display(), rangeY, graphHeight));
                    bar.lineTo(
                            (float) mapX(
                                    saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)) + barWidth,
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date + twoSigma, getMaxY_Display(), rangeY, graphHeight));
                    bar.lineTo(
                            (float) mapX(
                                    saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)) + barWidth,
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date - twoSigma, getMaxY_Display(), rangeY, graphHeight));
                    bar.lineTo(
                            (float) mapX(saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)),
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date - twoSigma, getMaxY_Display(), rangeY, graphHeight));
                    bar.closePath();

                    Composite originalComposite = g2d.getComposite();

                    if (SAM.getIncludedFractionIDsVector().contains(fID)) {
                        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f));
                        totalWeight += Math.pow(invertedOneSigma, 2.0);

                        // april 2014 experiment
                        if (f.getRgbColor() != 0) {
                            includedFillColor = new Color(f.getRgbColor());
                        }

                    } else {
                        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
                    }

                    g2d.setPaint(includedFillColor);

                    g2d.draw(bar);
                    //restore composite
                    g2d.setComposite(originalComposite);

                    g2d.setColor(Color.black);

                    // label fraction at top
                    g2d.rotate(-Math.PI / 4.0,
                            (float) mapX(saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)),
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date + twoSigma, getMaxY_Display(), rangeY, graphHeight));

                    g2d.drawString(
                            ((UPbReduxAliquot) selectedSampleDateModels[i][0]).getAliquotFractionByName(fID)
                                    .getFractionID(),
                            (float) mapX(saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)),
                                    getMinX_Display(), rangeX, graphWidth) + 15,
                            (float) mapY(date + twoSigma, getMaxY_Display(), rangeY, graphHeight));

                    g2d.rotate(Math.PI / 4.0,
                            (float) mapX(saveStartSamX + ((barGap / 2.0) + barNum * (barWidth + barGap)),
                                    getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(date + twoSigma, getMaxY_Display(), rangeY, graphHeight));

                    barNum++;
                    // startSamX += 2 * barWidth;
                    startSamX += barWidth + barGap;
                }

                // display three info boxes below weighted means
                // each tic is the height of one calculated y-axis tic
                // determine the y axis tic
                double minYtic = Math.ceil(getMinY_Display() * 100) / 100;
                double maxYtic = Math.floor(getMaxY_Display() * 100) / 100;
                double deltay = Math.rint((maxYtic - minYtic) * 10 + 0.5);
                double yTic = deltay / 100;

                double yTopSummary = minPoint - yTic / 2.0;// wMeanOneSigma;
                //double specialYTic = yTic;
                double yTopWeights = yTopSummary - yTic * 1.1;
                double yTopMSWD_PDF = yTopWeights - yTic * 1.1;

                // summary box
                Path2D box = new Path2D.Double(Path2D.WIND_NON_ZERO);
                box.moveTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopSummary - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopSummary - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.closePath();

                g2d.setStroke(new BasicStroke(1.5f));
                g2d.draw(box);

                // Info Box
                g2d.drawString(//
                        SAM.getAliquot().getAliquotName(),
                        (float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth) + 4f,
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight) + 13f);
                g2d.drawString(//
                        SAM.getName(), (float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth) + 4f,
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight) + 25f);
                g2d.drawString(//
                        SAM.FormatValueAndTwoSigmaABSThreeWaysForPublication(6, 2),
                        (float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth) + 4f,
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight) + 36f);
                g2d.drawString(//
                        SAM.ShowCustomMSWDwithN(),
                        (float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth) + 4f,
                        (float) mapY(yTopSummary, getMaxY_Display(), rangeY, graphHeight) + 48f);

                // weights box
                box.reset();
                box.moveTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopWeights, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopWeights, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopWeights - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopWeights - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.closePath();

                g2d.setStroke(new BasicStroke(1.5f));
                g2d.draw(box);

                // plot fraction weights
                double artificialXRange = allFIDs.size();
                double count = 0;
                //double weightWidth = Math.min(3.0 * barWidth, (yTic / rangeY * graphHeight)) - 15;//yTic;//barWidth * 2.0;
                double weightWidth = (barWidth + barGap) * 0.9;

                for (String fID : allFIDs) {
                    // the dateModel has an associated aliquot, but in sample mode, it is a
                    // standin aliquot for the sample.  to get the aliquot number for
                    // use in coloring fractions, we need to query the fraction itself
                    String aliquotName = sample.getAliquotNameByFractionID(fID);

                    Fraction f = ((UPbReduxAliquot) selectedSampleDateModels[i][0])
                            .getAliquotFractionByName(fID);

                    Color includedFillColor = new Color(0, 0, 0);
                    if (sample.getSampleDateInterpretationGUISettings().getAliquotOptions().get(aliquotName)
                            .containsKey("includedFillColor")) {
                        String[] temp = //
                                sample.getSampleDateInterpretationGUISettings().getAliquotOptions()
                                        .get(aliquotName).get("includedFillColor").split(",");
                        includedFillColor = buildRGBColor(temp);
                    }

                    double invertOneSigma = //
                            1.0 //
                                    / ((UPbReduxAliquot) selectedSampleDateModels[i][0])
                                            .getAliquotFractionByName(fID)//
                                            .getRadiogenicIsotopeDateByName(SAM.getDateName()).getOneSigmaAbs()
                                            .movePointLeft(6).doubleValue();

                    Path2D weight = new Path2D.Double(Path2D.WIND_NON_ZERO);
                    weight.moveTo(
                            (float) mapX(saveStartSamX + (count + 0.5) / artificialXRange * actualWidthX,
                                    getMinX_Display(), rangeX, graphWidth) //
                                    - (float) (invertOneSigma / maxWeight / 2.0 * weightWidth),
                            (float) mapY(yTopWeights - (yTic / 2.0), getMaxY_Display(), rangeY, graphHeight) //
                                    + (float) (invertOneSigma / maxWeight / 2.0 * weightWidth) - 5f);

                    weight.lineTo(
                            (float) mapX(saveStartSamX + (count + 0.5) / artificialXRange * actualWidthX,
                                    getMinX_Display(), rangeX, graphWidth) //
                                    + (float) (invertOneSigma / maxWeight / 2.0 * weightWidth),
                            (float) mapY(yTopWeights - (yTic / 2.0), getMaxY_Display(), rangeY, graphHeight) //
                                    + (float) (invertOneSigma / maxWeight / 2.0 * weightWidth) - 5f);

                    weight.lineTo(
                            (float) mapX(saveStartSamX + (count + 0.5) / artificialXRange * actualWidthX,
                                    getMinX_Display(), rangeX, graphWidth) //
                                    + (float) (invertOneSigma / maxWeight / 2.0 * weightWidth),
                            (float) mapY(yTopWeights - (yTic / 2.0), getMaxY_Display(), rangeY, graphHeight) //
                                    - (float) (invertOneSigma / maxWeight / 2.0 * weightWidth) - 5f);

                    weight.lineTo(
                            (float) mapX(saveStartSamX + (count + 0.5) / artificialXRange * actualWidthX,
                                    getMinX_Display(), rangeX, graphWidth) //
                                    - (float) (invertOneSigma / maxWeight / 2.0 * weightWidth),
                            (float) mapY(yTopWeights - (yTic / 2.0), getMaxY_Display(), rangeY, graphHeight) //
                                    - (float) (invertOneSigma / maxWeight / 2.0 * weightWidth) - 5f);

                    weight.closePath();

                    g2d.setStroke(new BasicStroke(2.5f));

                    // test for included or not == black or gray
                    String weightPerCent = "   0";//0.0%";

                    //                        g2d.setPaint(includedFillColor);
                    Composite originalComposite = g2d.getComposite();

                    if (SAM.getIncludedFractionIDsVector().contains(fID)) {
                        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f));
                        weightPerCent = formatter1DecPlace
                                .format(Math.pow(invertOneSigma, 2.0) / totalWeight * 100.0);// + "%";

                        // april 2014 experiment
                        if (f.getRgbColor() != 0) {
                            includedFillColor = new Color(f.getRgbColor());
                        }
                    } else {
                        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
                    }

                    g2d.setPaint(includedFillColor);

                    g2d.fill(weight);
                    //restore composite
                    g2d.setComposite(originalComposite);

                    // write percent of total weight
                    g2d.drawString(weightPerCent,
                            (float) mapX(saveStartSamX + (count + 0.5) / artificialXRange * actualWidthX,
                                    getMinX_Display(), rangeX, graphWidth) //
                                    - (float) (invertOneSigma / maxWeight / 2.0 * weightWidth),
                            (float) mapY(yTopWeights - yTic, getMaxY_Display(), rangeY, graphHeight) - 5f);
                    g2d.setColor(Color.black);

                    count += 1.0;

                }

                // double box height for graph
                yTic *= 2.0;

                // plot MSWD_PDF
                // store  function x,y values
                Vector<Double> xVals = new Vector<Double>();
                Vector<Double> yVals = new Vector<Double>();

                double f = SAM.getIncludedFractionIDsVector().size() - 1;
                if (f > 1.0) {
                    g2d.setStroke(new BasicStroke(1.0f));

                    double yRange = MSWDCoordinates.valuesByPointCount[(int) f][5] * 1.03; // alitle air at the top of curve
                    double xStart = MSWDCoordinates.valuesByPointCount[(int) f][1];
                    double xRange = MSWDCoordinates.valuesByPointCount[(int) f][4] - xStart;
                    double xStep = 0.005;

                    Path2D MSWD_PDF = new Path2D.Double(Path2D.WIND_NON_ZERO);
                    Path2D MSWD_right = new Path2D.Double(Path2D.WIND_NON_ZERO);

                    // start at lower left corner of box  (may or may not be 0,0 )
                    MSWD_PDF.moveTo(//
                            (float) mapX((double) saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                            (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));

                    // setup MSWD to paint last
                    Path2D MSWD = null;

                    // calculate function values
                    for (double x = xStart; x < xRange; x += xStep) {
                        xVals.add((((x - xStart) / xRange) * actualWidthX) + (double) saveStartSamX);

                        double y = //
                                Math.pow(2, -1.0 * f / 2.0)//
                                        * Math.exp(-1.0 * f * x / 2.0)//
                                        * Math.pow(f, f / 2.0)//
                                        * Math.pow(x, (-1.0 + f / 2.0))//
                                        / Math.exp(Gamma.logGamma(f / 2.0));

                        yVals.add(((y / yRange) * yTic) + yTopMSWD_PDF - yTic);

                        MSWD_PDF.lineTo(//
                                (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                        // test for location of left RED zone
                        if ((MSWDCoordinates.valuesByPointCount[(int) f][2] >= x)
                                && (MSWDCoordinates.valuesByPointCount[(int) f][2] < (x + xStep))) {

                            double leftX = MSWDCoordinates.valuesByPointCount[(int) f][2];
                            xVals.add((((leftX - xStart) / xRange) * actualWidthX) + (double) saveStartSamX);

                            double leftY = //
                                    Math.pow(2, -1.0 * f / 2.0)//
                                            * Math.exp(-1.0 * f * leftX / 2.0)//
                                            * Math.pow(f, f / 2.0)//
                                            * Math.pow(leftX, (-1.0 + f / 2.0))//
                                            / Math.exp(Gamma.logGamma(f / 2.0));
                            yVals.add(((leftY / yRange) * yTic) + yTopMSWD_PDF - yTic);

                            MSWD_PDF.lineTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                            Path2D ciLower = new Path2D.Double(Path2D.WIND_NON_ZERO);
                            ciLower.append(MSWD_PDF.getPathIterator(new AffineTransform()), true);

                            ciLower.lineTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                            ciLower.closePath();
                            g2d.setColor(Color.RED);
                            g2d.fill(ciLower);

                            // draw right hand border line to compensate for a bug in the filler
                            Line2D right = new Line2D.Double(//
                                    mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight),
                                    mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                            g2d.setStroke(new BasicStroke(0.5f));
                            g2d.draw(right);
                            g2d.setStroke(new BasicStroke(1.0f));

                            g2d.setColor(Color.BLACK);

                            System.out.println("Left Red = (" + leftX + ", " + leftY + ")");
                        }

                        // test for location of right RED zone
                        if ((MSWDCoordinates.valuesByPointCount[(int) f][3] >= x)
                                && (MSWDCoordinates.valuesByPointCount[(int) f][3] < (x + xStep))) {

                            double rightX = MSWDCoordinates.valuesByPointCount[(int) f][3];
                            xVals.add((((rightX - xStart) / xRange) * actualWidthX) + (double) saveStartSamX);

                            double rightY = //
                                    Math.pow(2, -1.0 * f / 2.0)//
                                            * Math.exp(-1.0 * f * rightX / 2.0)//
                                            * Math.pow(f, f / 2.0)//
                                            * Math.pow(rightX, (-1.0 + f / 2.0))//
                                            / Math.exp(Gamma.logGamma(f / 2.0));
                            yVals.add(((rightY / yRange) * yTic) + yTopMSWD_PDF - yTic);

                            MSWD_PDF.lineTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                            // here the strategy is to draw the curve and then reset it to record the remainder
                            g2d.setStroke(new BasicStroke(1.0f));
                            g2d.draw(MSWD_PDF);
                            MSWD_PDF = new Path2D.Double(Path2D.WIND_NON_ZERO);
                            MSWD_PDF.moveTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                            MSWD_right.moveTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                            MSWD_right.lineTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                            System.out.println("Right Red = (" + rightX + ", " + rightY + ")");

                        }

                        // test for location of MSWD AND paint last
                        if ((SAM.getMeanSquaredWeightedDeviation().doubleValue() >= x)
                                && (SAM.getMeanSquaredWeightedDeviation().doubleValue() < (x + xStep))) {
                            MSWD = new Path2D.Double(Path2D.WIND_NON_ZERO);
                            MSWD.moveTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                            MSWD.lineTo(//
                                    (float) mapX(xVals.lastElement(), getMinX_Display(), rangeX, graphWidth),
                                    (float) mapY(yVals.lastElement(), getMaxY_Display(), rangeY, graphHeight));

                        }
                    }
                    g2d.setStroke(new BasicStroke(1.0f));
                    // merge with border of right RED and fill
                    MSWD_right.append(MSWD_PDF.getPathIterator(new AffineTransform()), true);
                    g2d.setColor(Color.RED);
                    g2d.fill(MSWD_right);
                    g2d.setColor(Color.BLACK);
                    // draw the remaining curves
                    g2d.draw(MSWD_PDF);
                    // MSWD may be off the graph and hence not exist
                    try {
                        g2d.draw(MSWD);
                    } catch (Exception e) {
                    }

                    // label 95% conf interval and MSWD
                    g2d.drawString(//
                            "95% CI: ("
                                    + formatter2DecPlaces.format(MSWDCoordinates.valuesByPointCount[(int) f][2])
                                    + ", "
                                    + formatter2DecPlaces.format(MSWDCoordinates.valuesByPointCount[(int) f][3])
                                    + ")",
                            (float) mapX(saveStartSamX + (actualWidthX / 2.0), getMinX_Display(), rangeX,
                                    graphWidth) - 30f,
                            (float) mapY(yTopMSWD_PDF, getMaxY_Display(), rangeY, graphHeight) + 15f);

                    // determine if MSWD is out of range
                    String mswdAlert = "";
                    if (SAM.getMeanSquaredWeightedDeviation()
                            .doubleValue() > MSWDCoordinates.valuesByPointCount[(int) f][4]) {
                        mswdAlert = "\n !Out of Range!";
                    }
                    g2d.drawString(//
                            "MSWD = "
                                    + formatter2DecPlaces
                                            .format(SAM.getMeanSquaredWeightedDeviation().doubleValue())
                                    + ", n = " + (int) (f + 1) + mswdAlert,
                            (float) mapX(saveStartSamX + (actualWidthX / 2.0), getMinX_Display(), rangeX,
                                    graphWidth) - 15f,
                            (float) mapY(yTopMSWD_PDF, getMaxY_Display(), rangeY, graphHeight) + 30f);

                } else {
                    g2d.drawString("need more data...",
                            (float) mapX((double) saveStartSamX, getMinX_Display(), rangeX, graphWidth) + 4f,
                            (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight) - 10f);
                }

                // MSWD_PDF box
                box.reset();
                box.moveTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopMSWD_PDF, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopMSWD_PDF, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX + actualWidthX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.lineTo((float) mapX(saveStartSamX, getMinX_Display(), rangeX, graphWidth),
                        (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                box.closePath();

                g2d.setStroke(new BasicStroke(1.5f));
                g2d.draw(box);

                // MSWD_PDF x-axis tics
                if (f > 1.0) {
                    g2d.setStroke(new BasicStroke(1.0f));
                    double xStart = (MSWDCoordinates.valuesByPointCount[(int) f][1] <= 0.5) ? 0.5 : 1.0;
                    double xRange = MSWDCoordinates.valuesByPointCount[(int) f][4]
                            - MSWDCoordinates.valuesByPointCount[(int) f][1];
                    double xStep = 0.5;

                    for (double x = xStart; x < xRange; x += xStep) {
                        double xPlot = (((x - MSWDCoordinates.valuesByPointCount[(int) f][1]) / xRange)
                                * actualWidthX) + (double) saveStartSamX;
                        Line2D line = new Line2D.Double(mapX(xPlot, getMinX_Display(), rangeX, graphWidth),
                                mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight),
                                mapX(xPlot, getMinX_Display(), rangeX, graphWidth),
                                mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight) + 7);
                        g2d.draw(line);

                        g2d.rotate(-Math.PI / 2.0, (float) mapX(xPlot, getMinX_Display(), rangeX, graphWidth),
                                (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                        g2d.drawString(formatter1DecPlace.format(x),
                                (float) mapX(xPlot, getMinX_Display(), rangeX, graphWidth) - 30f,
                                (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight) + 5f);
                        g2d.rotate(Math.PI / 2.0, (float) mapX(xPlot, getMinX_Display(), rangeX, graphWidth),
                                (float) mapY(yTopMSWD_PDF - yTic, getMaxY_Display(), rangeY, graphHeight));
                    }
                }

                // set counters
                barNum += samSpace;
                startSamX += 2 * samSpace * barWidth;
            }
        }
    }
    //        // prevents re-randomization
    //        setInRandomMode( true );

    drawAxesAndTicks(g2d, rangeX, rangeY);

    // draw zoom box if in use
    if ((Math.abs(zoomMaxX - zoomMinX) * Math.abs(zoomMinY - zoomMaxY)) > 0.0) {
        g2d.setStroke(new BasicStroke(2.0f));
        g2d.setColor(Color.red);
        g2d.drawRect(//
                Math.min(zoomMinX, zoomMaxX), Math.min(zoomMaxY, zoomMinY), Math.abs(zoomMaxX - zoomMinX),
                Math.abs(zoomMinY - zoomMaxY));
    }
}

From source file:com.esri.ArcGISController.java

@RequestMapping(value = "/rest/services/InfoUSA/MapServer/export", method = { RequestMethod.GET,
        RequestMethod.POST })//from   w  w w.ja va2 s . co  m
public void doExport(@RequestParam("bbox") final String bbox,
        @RequestParam(value = "size", required = false) final String size,
        @RequestParam(value = "layerDefs", required = false) final String layerDefs,
        @RequestParam(value = "transparent", required = false) final String transparent,
        final HttpServletResponse response) throws IOException {
    double xmin = -1.0, ymin = -1.0, xmax = 1.0, ymax = 1.0;
    if (bbox != null && bbox.length() > 0) {
        final String[] tokens = m_patternComma.split(bbox);
        if (tokens.length == 4) {
            xmin = Double.parseDouble(tokens[0]);
            ymin = Double.parseDouble(tokens[1]);
            xmax = Double.parseDouble(tokens[2]);
            ymax = Double.parseDouble(tokens[3]);
        } else {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST,
                    "bbox is not in the form xmin,ymin,xmax,ymax");
            return;
        }
    } else {
        response.sendError(HttpServletResponse.SC_BAD_REQUEST, "bbox is null or empty");
        return;
    }

    final double xdel = xmax - xmin;
    final double ydel = ymax - ymin;

    int imageWidth = 400;
    int imageHeight = 400;
    if (size != null && size.length() > 0) {
        final String[] tokens = m_patternComma.split(size);
        if (tokens.length == 2) {
            imageWidth = Integer.parseInt(tokens[0], 10);
            imageHeight = Integer.parseInt(tokens[1], 10);
        } else {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, "size is not in the form width,height");
            return;
        }
    }
    String where = null;
    double lo = Double.NaN;
    double hi = Double.NaN;
    int[] ramp = null;
    if (layerDefs != null) {
        final String[] tokens = m_patternSemiColon.split(layerDefs);
        for (final String token : tokens) {
            final String[] keyval = m_patternEqual.split(token.substring(2));
            if (keyval.length == 2) {
                final String key = keyval[0];
                final String val = keyval[1];
                if ("lo".equalsIgnoreCase(key)) {
                    lo = "NaN".equalsIgnoreCase(val) ? Double.NaN : Double.parseDouble(val);
                } else if ("hi".equalsIgnoreCase(key)) {
                    hi = "NaN".equalsIgnoreCase(val) ? Double.NaN : Double.parseDouble(val);
                } else if ("ramp".equalsIgnoreCase(key)) {
                    ramp = parseRamp(val);
                } else if ("where".equalsIgnoreCase(key)) {
                    where = val;
                }
            }
        }
    }
    if (ramp == null) {
        ramp = new int[] { 0xFFFFFF, 0x000000 };
    }

    final Range range = new Range();
    final Map<Long, Double> map = query(where, xmin, ymin, xmax, ymax, range);
    if (!Double.isNaN(lo)) {
        range.lo = lo;
    }
    if (!Double.isNaN(hi)) {
        range.hi = hi;
    }
    range.dd = range.hi - range.lo;

    final int typeIntRgb = "true".equalsIgnoreCase(transparent) ? BufferedImage.TYPE_INT_ARGB
            : BufferedImage.TYPE_INT_RGB;
    BufferedImage bufferedImage = new BufferedImage(imageWidth, imageHeight, typeIntRgb);
    final Graphics2D graphics = bufferedImage.createGraphics();
    try {
        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        graphics.setBackground(new Color(0, 0, 0, 0));

        drawCells(graphics, imageWidth, imageHeight, xmin, ymin, xdel, ydel, range, ramp, map.entrySet());
    } finally {
        graphics.dispose();
    }

    // bufferedImage = m_op.filter(bufferedImage, null);

    final ByteArrayOutputStream baos = new ByteArrayOutputStream(10 * 1024);
    ImageIO.write(bufferedImage, "PNG", baos);

    response.setStatus(HttpServletResponse.SC_OK);
    response.setContentType("image/png");
    response.setContentLength(baos.size());
    baos.writeTo(response.getOutputStream());
    response.getOutputStream().flush();
}

From source file:org.elasticwarehouse.core.parsers.FileTools.java

private static BufferedImage resizeImageWithHint(BufferedImage originalImage, int type, int IMG_WIDTH,
        int IMG_HEIGHT) {

    BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, type);
    Graphics2D g = resizedImage.createGraphics();
    g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
    g.dispose();/*from w w  w . ja v a2s.c  o  m*/
    g.setComposite(AlphaComposite.Src);

    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    return resizedImage;
}

From source file:org.tros.logo.swing.LogoPanel.java

@Override
public void backward(final double distance) {
    Drawable command = new Drawable() {

        @Override//  www.  j  a  va  2  s  .  co m
        public void draw(Graphics2D g2, TurtleState turtleState) {
            double newx = turtleState.penX - (distance * Math.cos(turtleState.angle));
            double newy = turtleState.penY - (distance * Math.sin(turtleState.angle));

            if (!turtleState.penup) {
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2.draw(new Line2D.Double(turtleState.penX, turtleState.penY, newx, newy));
            }

            turtleState.penX = newx;
            turtleState.penY = newy;
        }

        @Override
        public void addListener(DrawListener listener) {
        }

        @Override
        public void removeListener(DrawListener listener) {
        }

        @Override
        public Drawable cloneDrawable() {
            return this;
        }
    };
    submitCommand(command);
}