abstractimageformatter.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

                Debug.output("AbstractImageFormatter can't get layers from map!");
            }

            map.removePropertyChangeListener(this);
            layers = null;
        }

        return getImageBytes();
    }

    /**
     * Return the applicable Graphics to use to paint the layers into.
     * If the internal BufferedImage hasn't been created yet, or has
     * been set to null, then a new buffered Image is created, set to
     * the size specified by the height and width. The ImageGenerator
     * extends MapBean. Remember to dispose of the graphics object
     * when you are done with it. Uses the default
     * BufferedImage.TYPE_INT_RGB colormodel.
     * 
     * @param width pixel width of Graphics.
     * @param height pixel height of Graphics.
     * @return Graphics object to use.
     * @see java.awt.image.BufferedImage
     */
    public Graphics getGraphics(int width, int height) {
        return getGraphics(width, height, BufferedImage.TYPE_INT_RGB);
    }

    /**
     * Return the applicable Graphics to use to paint the layers into.
     * If the internal BufferedImage hasn't been created yet, or has
     * been set to null, then a new buffered Image is created, set to
     * the size specified by the height and width. The ImageGenerator
     * extends MapBean. Remember to dispose of the graphics object
     * when you are done with it. Lets you select the image type.
     * 
     * @param width pixel width of Graphics.
     * @param height pixel height of Graphics.
     * @param imageType image type - see BufferedImage
     * @return java.awt.Graphics object to use.
     * @see java.awt.image.BufferedImage
     */
    public Graphics getGraphics(int width, int height, int imageType) {
        bufferedImage = new BufferedImage(width, height, imageType);

        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        Graphics g = ge.createGraphics(bufferedImage);
        g.setClip(0, 0, width, height);
        return g;
    }

    /**
     * Return the BufferedImage contained within the formatter.
     * 
     * @return the BufferedImage.
     */
    public BufferedImage getBufferedImage() {
        return bufferedImage;
    }

    /**
     * Return the BufferedImage contained within the formatter.
     * 
     * @param bi the BufferedImage to use in this formatter.
     */
    public void setBufferedImage(BufferedImage bi) {
        bufferedImage = bi;
    }

    /**
     * Scale the internal BufferedImage to the pixel dimensions, and
     * then return it.
     * 
     * @param scaledWidth the desired pixel width of the image.
     * @param scaledHeight the desired pixel height of the image.
     * @return the scaled BufferedImage.
     */
    public BufferedImage getScaledBufferedImage(int scaledWidth,
                                                int scaledHeight) {

        if (bufferedImage == null) {
            return null;
        }

        if (Debug.debugging("formatter")) {
            Debug.output("Formatter: scaling image to : " + scaledWidth + ", "
                    + scaledHeight);
        }

        java.awt.Image image = bufferedImage.getScaledInstance(scaledWidth,
                scaledHeight,
                java.awt.Image.SCALE_SMOOTH);

        if (Debug.debugging("formatter")) {
            Debug.output("Formatter: creating scaled image...");
        }

        try {

            BufferedImage buffi = BufferedImageHelper.getBufferedImage(image,
                    0,
                    0,
                    -1,
                    -1);

            // Do this here, in case something bad happens in the
            // buffered image creation, so at least the original image
            // is retained.
            bufferedImage = buffi;
        } catch (InterruptedException ie) {
            Debug.error("Formatter: Something bad happened during scaling! \n"
                    + ie);
        }

        if (Debug.debugging("formatter")) {
            Debug.output("Formatter: image successfully scaled");
        }

        return bufferedImage;
    }

    /**
     * Return the image bytes of the formatted image.
     * 
     * @return byte[] representing the image.
     */
    public byte[] getImageBytes() {
        BufferedImage bi = getBufferedImage();
        if (bi == null) {
            return new byte[0];
        } else {
            Debug.message("formatter",
                    "Formatter: creating formatted image bytes...");
            return formatImage(bi);
        }
    }

    /**
     * Scale the internal BufferedImage, then return the image bytes
     * of the formatted image.
     * 
     * @param scaledWidth the desired pixel width of the image.
     * @param scaledHeight the desired pixel height of the image.
     * @return byte[] representing the image.
     */
    public byte[] getScaledImageBytes(int scaledWidth, int scaledHeight) {
        BufferedImage bi = getScaledBufferedImage(scaledWidth, scaledHeight);
        if (bi == null) {
            return new byte[0];
        } else {
            Debug.message("formatter",
                    "Formatter: creating formatted image bytes...");
            return formatImage(bi);
        }
    }

    /**
     * Set the layers and image type in the properties.
     */
    public void setProperties(Properties props) {
        setProperties((String) null, props);
    }

    /**
     * Part of the PropertyConsumer interface. Doesn't do anything
     * yet.
     */
    public Properties getProperties(Properties props) {
        if (props == null) {
            props = new Properties();
        }
        return props;
    }

    /**
     * Part of the PropertyConsumer interface.
     */
    public Properties getPropertyInfo(Properties list) {
        if (list == null) {
            list = new Properties();
        }
        return list;

    }

    /**
     * Part of the PropertyConsumer interface. Set the Properties
     * prefix to use to scope the relevant properties passed into the
     * setProperties method.
     */
    public void setPropertyPrefix(String prefix) {
        propertiesPrefix = prefix;
    }

    /**
     * Part of the PropertyConsumer interface. Get the Properties
     * prefix used to scope the relevant properties passed into the
     * setProperties method.
     */
    public String getPropertyPrefix() {
        return propertiesPrefix;
    }

    /**
     * Used when the layers from the MapBean are needed, in order to
     * use the renderDataForProjection method.
     */
    protected Layer[] layers = null;

    /**
     * Used when the layers from the MapBean are needed, in order to
     * use the renderDataForProjection method. Sets the Layer[] by
     * adding the formatter as a PropertyChangeListener to the
     * MapBean. Remember to remove the formatter from the MapBean as a
     * PropertyChangeListener.
     */
    public void propertyChange(PropertyChangeEvent pce) {
        String propName = pce.getPropertyName();
        if (propName == MapBean.LayersProperty) {
            layers = (Layer[]) pce.getNewValue();
        }
    }
}