webmapnasbimageexporter.java

esri的ArcGIS Server超级学习模板程序（for java）

package com.esri.solutions.jitk.common.export.image;

import com.esri.adf.web.data.GraphicElement;
import com.esri.adf.web.data.WebContext;
import com.esri.adf.web.data.WebElementConverter;
import com.esri.adf.web.data.WebMap;
import com.esri.adf.web.data.WebNorthArrow;
import com.esri.adf.web.data.WebScaleBar;
import com.esri.adf.web.data.export.ExportProperties;
import com.esri.adf.web.data.geometry.WebPoint;
import com.esri.adf.web.data.symbol.WebScalebarSymbol;
import com.esri.adf.web.data.symbol.WebTrueTypeMarkerSymbol;

import com.esri.internal.adf.web.data.display.ScalebarSymbol;
import com.esri.internal.adf.web.data.display.WebSymbolConverter;
import com.esri.internal.adf.web.data.display.geometry.BasePath;
import com.esri.internal.adf.web.data.display.geometry.PointCollection;

import org.apache.log4j.Logger;

import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import java.util.List;

import javax.imageio.ImageIO;


public class WebMapNASBImageExporter extends WebMapImageExporter {
    private static final Logger _logger = Logger.getLogger(WebMapNASBImageExporter.class);
    private WebContext _webContext = null;
    private boolean _exportNorthArrow = true;
    private boolean _exportScalebar = true;

    public WebMapNASBImageExporter(WebContext webContext) {
        super();

        _webContext = webContext;
    }

    public void setExportNorthArrow(boolean export) {
        _exportNorthArrow = export;
    }

    public void setExportScalebar(boolean export) {
        _exportScalebar = export;
    }

    /**
    * Export the north arrow by placing it on a converter drawing surface
    * @param context the web context
    * @param arrow the north arrow
    * @param converter the converter to some display device
    * @throws Exception the exception
    */
    private void exportNorthArrow(WebContext context, WebNorthArrow arrow,
        WebElementConverter converter) throws Exception {
        converter.draw(createNorthArrow(arrow,
                new WebPoint(arrow.getWidth() / 2, arrow.getHeight() / 2),
                context.getWebMap().getRotation()));
    }

    /**
     * Creates a graphic element representing a north arrow
     * @param arrow the north arrow
     * @param pt the location to set it at
     * @param rotation the rotation of the arrow in decimal degrees
     * @return the generated graphic element
     */
    private GraphicElement createNorthArrow(WebNorthArrow arrow, WebPoint pt,
        double rotation) {
        WebTrueTypeMarkerSymbol sym = createNorthArrowSymbol(arrow, rotation);
        GraphicElement element = new GraphicElement();
        element.setGeometry(pt);
        element.setSymbol(sym);

        return element;
    }

    /**
     * Creates a WebTrueTypeMarkerSymbol representing a north arrow
     * @param arrow the arrow
     * @param rotation the rotation
     * @return the true marker symbol that looks like a north arrow
     */
    private WebTrueTypeMarkerSymbol createNorthArrowSymbol(
        WebNorthArrow arrow, double rotation) {
        WebTrueTypeMarkerSymbol sym = new WebTrueTypeMarkerSymbol();
        sym.setFontName(arrow.getFontName());
        sym.setCharacterIndex(arrow.getFontCharacter());
        sym.setFontSize(arrow.getFontSize());
        sym.setFontStyle(arrow.getFontStyle());
        sym.setFontColor(arrow.getFontColor());
        sym.setOutlineColor(arrow.getFontOutlineColor());
        sym.setShadowColor(arrow.getFontShadowColor());
        sym.setGlowingColor(arrow.getFontGlowingColor());
        sym.setAngle(rotation);
        sym.setAntialiasing(arrow.isAntialiasing());
        sym.setTransparency(arrow.getTransparency());

        return sym;
    }

    protected void exportOther(ExportProperties props,
        List<InputStream> images, List<Double> transValues) {
        WebElementConverter converter = null;
        WebNorthArrow arrow = null;
        BufferedImage scaleImage = null;
        WebScaleBar scaleBar = null;
        WebScaleBar configuredBar = null;

        try {
            if (_exportNorthArrow) {
                converter = new WebElementConverter(props.getWidth(),
                        props.getHeight());

                arrow = new WebNorthArrow();
                arrow.init(_webContext);

                // add the north arrow
                exportNorthArrow(_webContext, arrow, converter);
                images.add(0, new ByteArrayInputStream(converter.getPNGImage()));
                transValues.add(0, 1.0D);
            }

            if (_exportScalebar) {
                // add the scale bar
                configuredBar = this.getScaleBar();

                scaleBar = new WebScaleBar();
                scaleBar.init(_webContext);

                if (configuredBar != null) {
                	_logger.info("Configured WebScaleBar found - setting scale bar properties");
                	
                	scaleBar.setType(configuredBar.getType());
                	scaleBar.setPosition(configuredBar.getPosition());
                	scaleBar.setMaxPrecision(configuredBar.getMaxPrecision());
                	scaleBar.setUnits(configuredBar.getUnits());
                	scaleBar.update(_webContext, null);
                } else {
                    _logger.info(
                        "No configured WebScaleBar found - using default scale bar");
                    _logger.debug(
                        "No WebScaleBar found in WebContext attributes, using default WebScaleBar with default properties");
                }

                if (!scaleBar.isScaleBarAvailable()) {
                    _logger.info(
                        "Unable to export WebScaleBar - scalebar is unavailable");

                    return;
                }

                scaleImage = new BufferedImage(props.getWidth(),
                        props.getHeight(), BufferedImage.TYPE_INT_ARGB);

                drawScaleSymbol(scaleBar,
                    (Graphics2D) scaleImage.getGraphics(), props);

                byte[] imageBytes = this.exportToBytes(scaleImage);

                images.add(0, new ByteArrayInputStream(imageBytes));
                transValues.add(0, 0.75D);
            }
        } catch (Exception ex) {
            _logger.warn("An exception has occurred exporting map image");
            _logger.debug("An exception has occurred exporting map image", ex);
        }
    }

    private WebScaleBar getScaleBar() {
        WebScaleBar scaleBar = null;

        for (Object o : _webContext.getAttributes().values()) {
            if (o instanceof WebScaleBar) {
                scaleBar = (WebScaleBar) o;

                break;
            }
        }

        if (scaleBar == null) {
            _logger.debug(
                "Unable to find WebScaleBar in WebContext attributes - returning null");
        }

        return scaleBar;
    }

    private void drawScaleSymbol(WebScaleBar scaleBar, Graphics2D g2d,
        ExportProperties props) {
        WebScalebarSymbol symbol = null;
        WebMap webMap = _webContext.getWebMap();
        BasePath path = null;
        PointCollection mpoint = null;
        ScalebarSymbol ssb = null;
        
        int width = webMap.getWidth();
        int height = webMap.getHeight();
        
        webMap.setWidth(props.getWidth());
        webMap.setHeight(props.getHeight());
        
        scaleBar.update(_webContext, null);
        
        // set the width and height of the webmap back to original values
        webMap.setWidth(width);
        webMap.setHeight(height);

        symbol = new WebScalebarSymbol();

        symbol.setWidth(scaleBar.getWidth());
        symbol.setMapDistance(scaleBar.getMapDistance());
        symbol.setType(scaleBar.getType());
        symbol.setAntialiasing(true);
        symbol.setUnit(scaleBar.getUnits());
        symbol.setFont(new Font("sans-serif", Font.PLAIN, 12));

        int off = (int) (10f);

        int x = off;

        int y = props.getHeight() - scaleBar.getHeight() - off;
        int w = scaleBar.getWidth();
        int h = scaleBar.getHeight() / 2;

        path = new BasePath();
        mpoint = new PointCollection();

        mpoint.addPoint(new java.awt.Point(x, y));
        mpoint.addPoint(new java.awt.Point(x + w, y));
        mpoint.addPoint(new java.awt.Point(x + w, y + h));
        mpoint.addPoint(new java.awt.Point(x, y + h));
        path.addPointCollection(mpoint);

        ssb = WebSymbolConverter.convertScalebarSymbol(symbol);

        try {
            ssb.draw(g2d, path);
        } catch (Exception ex) {
            _logger.warn("An Exception occurred drawing ScalebarSymbol");
            _logger.debug("An Exception occurred drawing ScalebarSymbol", ex);
        }
    }

    private byte[] exportToBytes(BufferedImage image) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        byte[] bytes = null;

        try {
            ImageIO.write(image, "png", outputStream);
            image.flush();

            bytes = outputStream.toByteArray();

            return bytes;
        } catch (IOException ex) {
            _logger.warn("Unable to export image bytes");
            _logger.debug("Unable to export image bytes", ex);

            return bytes;
        } finally {
            try {
                outputStream.close();
            } catch (IOException ex) {
                _logger.debug("An IOException occurred trying to close OutputStream",
                    ex);
            }
        }
    }
}