bufferedimageraster.java

world wind java sdk 源码

/* Copyright (C) 2001, 2008 United States Government as represented by
the Administrator of the National Aeronautics and Space Administration.
All Rights Reserved.
*/
package gov.nasa.worldwind.data;

import gov.nasa.worldwind.Disposable;
import gov.nasa.worldwind.cache.Cacheable;
import gov.nasa.worldwind.geom.Sector;
import gov.nasa.worldwind.util.Logging;

/**
 * @author dcollins
 * @version $Id: BufferedImageRaster.java 8321 2009-01-05 17:06:14Z dcollins $
 */
public class BufferedImageRaster implements DataRaster, Cacheable, Disposable
{
    private static final int MAX_IMAGE_SIZE_TO_CONVERT = 4096;

    private Sector sector;
    private java.awt.image.BufferedImage bufferedImage;
    private java.awt.Graphics2D g2d;

    public BufferedImageRaster(Sector sector, java.awt.image.BufferedImage bufferedImage)
    {
        if (sector == null)
        {
            String message = Logging.getMessage("nullValue.SectorIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (bufferedImage == null)
        {
            String message = Logging.getMessage("nullValue.ImageIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.sector = sector;
        this.bufferedImage = bufferedImage;
    }

    public BufferedImageRaster(int width, int height, int transparency, Sector sector)
    {
        if (width < 1)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", "width < 1");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (height < 1)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", "height < 1");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (sector == null)
        {
            String message = Logging.getMessage("nullValue.SectorIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.sector = sector;
        this.bufferedImage = createCompatibleImage(width, height, transparency);
    }

    public static java.awt.image.BufferedImage toCompatibleImage(java.awt.image.BufferedImage image)
    {
        if (image == null)
        {
            String message = Logging.getMessage("nullValue.ImageIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        // If the image is not already compatible, and is within the restrictions on dimension, then convert it
        // to a compatible image type.
        if (!isCompatibleImage(image)
            && (image.getWidth()  <= MAX_IMAGE_SIZE_TO_CONVERT)
            && (image.getHeight() <= MAX_IMAGE_SIZE_TO_CONVERT))
        {
            java.awt.image.BufferedImage compatibleImage =
                createCompatibleImage(image.getWidth(), image.getHeight(), image.getTransparency());
            java.awt.Graphics2D g2d = compatibleImage.createGraphics();
            g2d.drawImage(image, 0, 0, null);
            g2d.dispose();
            return compatibleImage;
        }
        // Otherwise return the original image.
        else
        {
            return image;
        }
    }

    public static java.awt.image.BufferedImage createCompatibleImage(int width, int height, int transparency)
    {
        if (width < 1)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", "width < 1");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (height < 1)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", "height < 1");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        java.awt.GraphicsConfiguration gc = getDefaultGraphicsConfiguration();
        return gc.createCompatibleImage(width, height, transparency);
    }

    protected static boolean isCompatibleImage(java.awt.image.BufferedImage image)
    {
        java.awt.GraphicsConfiguration gc = getDefaultGraphicsConfiguration();
        java.awt.image.ColorModel gcColorModel = gc.getColorModel(image.getTransparency());
        return image.getColorModel().equals(gcColorModel);
    }

    protected static java.awt.GraphicsConfiguration getDefaultGraphicsConfiguration()
    {
        java.awt.GraphicsEnvironment ge = java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment();
        java.awt.GraphicsDevice gd = ge.getDefaultScreenDevice();
        return gd.getDefaultConfiguration();
    }

    public int getWidth()
    {
        return this.bufferedImage.getWidth();
    }

    public int getHeight()
    {
        return this.bufferedImage.getHeight();
    }

    public Sector getSector()
    {
        return this.sector;
    }

    public java.awt.image.BufferedImage getBufferedImage()
    {
        return this.bufferedImage;
    }

    public java.awt.Graphics2D getGraphics()
    {
        if (this.g2d == null)
        {
            this.g2d = this.bufferedImage.createGraphics();
            // Enable bilinear interpolation.
            this.g2d.setRenderingHint(java.awt.RenderingHints.KEY_INTERPOLATION,
                java.awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        }
        return g2d;
    }

    public void drawOnCanvas(DataRaster canvas)
    {
        if (canvas == null)
        {
            String message = Logging.getMessage("nullValue.DestinationIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (!(canvas instanceof BufferedImageRaster))
        {
            String message = Logging.getMessage("DataRaster.IncompatibleRaster", canvas);
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.doDrawOnCanvas((BufferedImageRaster) canvas);
    }

    public long getSizeInBytes()
    {
        long size = 0L;
        java.awt.image.Raster raster = this.bufferedImage.getRaster();
        if (raster != null)
        {
            java.awt.image.DataBuffer db = raster.getDataBuffer();
            if (db != null)
                size = sizeOfDataBuffer(db);
        }
        return size;
    }

    public void dispose()
    {
        if (this.g2d != null)
        {
            this.g2d.dispose();
            this.g2d = null;
        }
    }

    protected void doDrawOnCanvas(BufferedImageRaster canvas)
    {
        if (!this.getSector().intersects(canvas.getSector()))
            return;

        java.awt.Graphics2D g2d = canvas.getGraphics();

        // Keep track of the previous transform.
        java.awt.geom.AffineTransform prevTransform = g2d.getTransform();

        // Apply the transform that will correctly map the image onto the canvas.
        java.awt.geom.AffineTransform transform = this.computeImageTransform(
            this.getWidth(), this.getHeight(), this.getSector(),
            canvas.getWidth(), canvas.getHeight(), canvas.getSector());
        g2d.setTransform(transform);
        // Render the image onto the canvas.
        g2d.drawImage(this.getBufferedImage(), 0, 0, null);

        // Restore the previous transform.
        g2d.setTransform(prevTransform);
    }

    protected java.awt.geom.AffineTransform computeImageTransform(int sourceWidth, int sourceHeight, Sector sourceSector,
                                                                  int destWidth, int destHeight, Sector destSector)
    {
        // Compute the the transform from source to destination coordinates. In this computation a pixel is assumed
        // to cover a finite area.

        double ty = destHeight * -(sourceSector.getMaxLatitude().degrees - destSector.getMaxLatitude().degrees)
                  / destSector.getDeltaLatDegrees();
        double tx = destWidth  * (sourceSector.getMinLongitude().degrees - destSector.getMinLongitude().degrees)
                  / destSector.getDeltaLonDegrees();
        
        double sy = ((double) destHeight / (double) sourceHeight)
                  * (sourceSector.getDeltaLatDegrees() / destSector.getDeltaLatDegrees());
        double sx = ((double) destWidth  / (double) sourceWidth)
                  * (sourceSector.getDeltaLonDegrees() / destSector.getDeltaLonDegrees());

        java.awt.geom.AffineTransform transform = new java.awt.geom.AffineTransform();
        transform.translate(tx, ty);
        transform.scale(sx, sy);
        return transform;
    }

    private static long sizeOfDataBuffer(java.awt.image.DataBuffer dataBuffer)
    {
        return sizeOfElement(dataBuffer.getDataType()) * dataBuffer.getSize();
    }

    private static long sizeOfElement(int dataType)
    {
        switch (dataType)
        {
            case java.awt.image.DataBuffer.TYPE_BYTE:
                return (Byte.SIZE / 8);
            case java.awt.image.DataBuffer.TYPE_DOUBLE:
                return (Double.SIZE / 8);
            case java.awt.image.DataBuffer.TYPE_FLOAT:
                return (Float.SIZE / 8);
            case java.awt.image.DataBuffer.TYPE_INT:
                return (Integer.SIZE / 8);
            case java.awt.image.DataBuffer.TYPE_SHORT:
            case java.awt.image.DataBuffer.TYPE_USHORT:
                return (Short.SIZE / 8);
            case java.awt.image.DataBuffer.TYPE_UNDEFINED:
                break;
        }
        return 0L;
    }
}