rpfpolarframetransform.java

来自「world wind java sdk 源码」· Java 代码 · 共 560 行 · 第 1/2 页

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

import gov.nasa.worldwind.geom.LatLon;
import gov.nasa.worldwind.geom.Sector;
import gov.nasa.worldwind.util.Logging;

import java.awt.image.*;

/**
 * @author dcollins
 * @version $Id: RPFPolarFrameTransform.java 4852 2008-03-28 19:14:52Z dcollins $
 */
@SuppressWarnings({"UnusedDeclaration"})
class RPFPolarFrameTransform extends RPFFrameTransform
{
    private final char zoneCode;
    private final String rpfDataType;
    private final double resolution;
    private final RPFPolarFrameStructure frameStructure;

    private static final PixelTransformer northernPixels = new NorthPixelTransformer();
    private static final PixelTransformer southernPixels = new SouthPixelTransformer();

    private RPFPolarFrameTransform(char zoneCode, String rpfDataType, double resolution,
        RPFPolarFrameStructure frameStructure)
    {
        this.zoneCode = zoneCode;
        this.rpfDataType = rpfDataType;
        this.resolution = resolution;
        this.frameStructure = frameStructure;
    }

    static RPFPolarFrameTransform createPolarFrameTransform(char zoneCode, String rpfDataType, double resolution)
    {
        if (!RPFZone.isZoneCode(zoneCode))
        {
            String message = Logging.getMessage("RPFZone.UnknownZoneCode", zoneCode);
            Logging.logger().fine(message);
            throw new IllegalArgumentException(message);
        }
        if (rpfDataType == null || !RPFDataSeries.isRPFDataType(rpfDataType))
        {
            String message = Logging.getMessage("RPFDataSeries.UnkownDataType", rpfDataType);
            Logging.logger().fine(message);
            throw new IllegalArgumentException(message);
        }
        if (resolution < 0)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", rpfDataType);
            Logging.logger().fine(message);
            throw new IllegalArgumentException(message);
        }

        RPFPolarFrameStructure frameStructure = RPFPolarFrameStructure.computeStructure(
            zoneCode, rpfDataType, resolution);
        return new RPFPolarFrameTransform(zoneCode, rpfDataType, resolution, frameStructure);
    }

    public final char getZoneCode()
    {
        return this.zoneCode;
    }

    public final String getRpfDataType()
    {
        return this.rpfDataType;
    }

    public final double getResolution()
    {
        return this.resolution;
    }

    public final RPFFrameStructure getFrameStructure()
    {
        return this.frameStructure;
    }

    public int getFrameNumber(int row, int column)
    {
        return frameNumber(row, column, this.frameStructure.getPolarFrames());
    }

    public int getMaximumFrameNumber()
    {
        return maxFrameNumber(this.frameStructure.getPolarFrames(), this.frameStructure.getPolarFrames());
    }

    public int getRows()
    {
        return this.frameStructure.getPolarFrames();
    }

    public int getColumns()
    {
        return this.frameStructure.getPolarFrames();
    }

    public LatLon computeFrameOrigin(int frameNumber)
    {

        if (frameNumber < 0 || frameNumber > getMaximumFrameNumber())
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", frameNumber);
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        int originX = pixelColumn(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());
        int originY = pixelRow(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());

        double lat, lon;
        PixelTransformer pt = (this.zoneCode == '9') ? northernPixels : southernPixels;
        lat = pt.pixel2Latitude(originX, originY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(originX, originY);

        return LatLon.fromDegrees(lat, lon);
    }

    public Sector computeFrameCoverage(int frameNumber)
    {
        int maxFrameNumber = getMaximumFrameNumber();
        if (frameNumber < 0 || frameNumber > maxFrameNumber)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", frameNumber);
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        int minX = pixelColumn(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());
        int maxY = pixelRow(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());

        int maxX = pixelColumn(this.frameStructure.getPixelRowsPerFrame(), frameNumber,
            this.frameStructure.getPixelRowsPerFrame(), this.frameStructure.getPolarFrames());
        int minY = pixelRow(this.frameStructure.getPixelRowsPerFrame(), frameNumber,
            this.frameStructure.getPixelRowsPerFrame(), this.frameStructure.getPolarFrames());

        // we'll need these below...
        int midX = (minX + maxX) / 2;
        int midY = (minY + maxY) / 2;

        // Find the bounds. This is kind of tedious...
        PixelTransformer pt = (this.zoneCode == '9') ? northernPixels : southernPixels;
        MinMaxLatLon bounds = new MinMaxLatLon();

        // LL
        double lat = pt.pixel2Latitude(minX, minY, this.frameStructure.getPolarPixelConstant());
        double lon = pt.pixel2Longitude(minX, minY);
        bounds.setMinMax(lat, lon);

        // LR
        lat = pt.pixel2Latitude(maxX, minY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(maxX, minY);
        bounds.setMinMax(lat, lon);

        // UL
        lat = pt.pixel2Latitude(minX, maxY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(minX, maxY);
        bounds.setMinMax(lat, lon);

        // UR
        lat = pt.pixel2Latitude(maxX, maxY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(maxX, maxY);
        bounds.setMinMax(lat, lon);

        // middle top
        lat = pt.pixel2Latitude(midX, maxY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(midX, maxY);
        bounds.setMinMax(lat, lon);

        // middle right
        lat = pt.pixel2Latitude(maxX, midY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(maxX, midY);
        bounds.setMinMax(lat, lon);

        // middle bottom
        lat = pt.pixel2Latitude(midX, minY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(midX, minY);
        bounds.setMinMax(lat, lon);

        // middle left
        lat = pt.pixel2Latitude(minX, midY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(minX, midY);
        bounds.setMinMax(lat, lon);

        // center
        lat = pt.pixel2Latitude(midX, midY, this.frameStructure.getPolarPixelConstant());
        lon = pt.pixel2Longitude(midX, midY);
        bounds.setMinMax(lat, lon);

        return Sector.fromDegrees(bounds.minLat, bounds.maxLat, bounds.minLon, bounds.maxLon);
    }

    public RPFImage[] deproject(int frameNumber, BufferedImage frame)
    {
        if (frame == null)
        {
            String message = Logging.getMessage("nullValue.ImageSource");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        PixelTransformer pt = (this.zoneCode == '9') ? northernPixels : southernPixels;

        RPFImage[] images;
        if (isDatelineSpanningFrame(frameNumber, pt))
        {
            if (pt == northernPixels)
                images = deprojectNorthernDatelineFrames(frameNumber, frame, pt);
            else
                images = deprojectSouthernDatelineFrames(frameNumber, frame, pt);
        }
        else
        {
            // non-dateline spanning frames are more straightforward...
            Sector sector = computeFrameCoverage(frameNumber);
            BufferedImage destImage = new BufferedImage(frame.getWidth(), frame.getHeight(),
                BufferedImage.TYPE_4BYTE_ABGR);
            resampleFrameFile(sector, frame, destImage, frameNumber, pt);
            images = new RPFImage[1];
            images[0] = new RPFImage(sector, destImage);
        }

        return images;
    }

    private RPFImage[] deprojectNorthernDatelineFrames(int frameNumber, BufferedImage frame, PixelTransformer pt)
    {
        // We have to split this frame at the dateline.
        RPFImage[] images = new RPFImage[2];

        // Compute a tight bounds for western half...
        int minX = pixelColumn(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());
        int maxX = pixelColumn(this.frameStructure.getPixelRowsPerFrame(), frameNumber,
            this.frameStructure.getPixelRowsPerFrame(), this.frameStructure.getPolarFrames());
        int minY = pixelRow(0, frameNumber, this.frameStructure.getPixelRowsPerFrame(),
            this.frameStructure.getPolarFrames());
        int maxY = pixelRow(this.frameStructure.getPixelRowsPerFrame(), frameNumber,
            this.frameStructure.getPixelRowsPerFrame(), this.frameStructure.getPolarFrames());
        int midX = (minX + maxX) / 2;
        int midY = (minY + maxY) / 2;

        // Below we are using knowledge about the frames that make up the upper 1/2 part of the middle
        // column, and which borders and edges constitute the extrema...

        MinMaxLatLon bndsWest = new MinMaxLatLon();
        bndsWest.minLon = -180.;
        // center-most frame is different...
        if (isCenterFrame(frameNumber))
        {
            bndsWest.maxLon = 0.;
            // here max lat is at center of frame
            bndsWest.maxLat = pt.pixel2Latitude(midX, midY, this.frameStructure.getPolarPixelConstant());
            // min lat is at an arbitrary corner...
            bndsWest.minLat = pt.pixel2Latitude(minX, minY, this.frameStructure.getPolarPixelConstant());
        }
        else
        {
            // min lat is one of the upper corners...
            bndsWest.minLat = pt.pixel2Latitude(minX, minY, this.frameStructure.getPolarPixelConstant());
            // max lat is center of bottom edge...
            bndsWest.maxLat = pt.pixel2Latitude(midX, maxY, this.frameStructure.getPolarPixelConstant());
            // LL corner of frame gives us max lon...
            bndsWest.maxLon = pt.pixel2Longitude(minX, maxY);
        }
        Sector sector = Sector.fromDegrees(bndsWest.minLat, bndsWest.maxLat, bndsWest.minLon, bndsWest.maxLon);
        BufferedImage destImage = new BufferedImage(frame.getWidth(), frame.getHeight(), BufferedImage.TYPE_4BYTE_ABGR);
        resampleFrameFile(sector, frame, destImage, frameNumber, pt);
        images[0] = new RPFImage(sector, destImage);