rpfgenerator.java

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

                    {
                        RPFFrameTransform.RPFImage[] images = getImageFromRPFSource(frame);
                         if (images == null)
                             continue;
                         for (RPFFrameTransform.RPFImage image : images) {
                             if (image.getSector() == null || image.getImage() == null) continue;
                             drawImageIntoRequest(reqImage, reqSector, image.getImage(), image.getSector());
                         }
                     }
                     else
                     {
                         int maxRes = footprintX;
                         maxRes = (footprintY > maxRes) ? footprintY : maxRes;
                         int power = (int) Math.ceil(Math.log(maxRes) / Math.log(2.));
                         int res = (int) Math.pow(2., power);
                         res = Math.max(1, res);

                         sourceImage = getImageFromWaveletEncoding(frame, res);
                         if (sourceImage == null)
                             continue;
                         drawImageIntoRequest(reqImage, reqSector, sourceImage, frameSector);
                    }

                    ++numFramesInRequest;
                }

                if (numFramesInRequest <= 0)
                    return null;

                return reqImage;
            }
            catch (Exception e)
            {
                String msg = "Exception while processing request";
                Logging.logger().log(java.util.logging.Level.SEVERE, msg, e);
                throw new IOException(msg);
            }
        }

        private void drawImageIntoRequest(BufferedImage reqImage, Sector reqSector, BufferedImage srcImage, Sector srcSector)
        {

            double tx = (srcSector.getMinLongitude().degrees - reqSector.getMinLongitude().degrees) * (
                reqImage.getWidth() / reqSector.getDeltaLonDegrees());
            double ty = (reqSector.getMaxLatitude().degrees - srcSector.getMaxLatitude().degrees) * (
                reqImage.getHeight() / reqSector.getDeltaLatDegrees());
            double sx = (reqImage.getWidth() / reqSector.getDeltaLonDegrees()) * (
                srcSector.getDeltaLonDegrees() / srcImage.getWidth());
            double sy = (reqImage.getHeight() / reqSector.getDeltaLatDegrees()) * (
                srcSector.getDeltaLatDegrees() / srcImage.getHeight());

            Graphics2D g2d = (Graphics2D) reqImage.getGraphics();
            AffineTransform xform = g2d.getTransform();
            g2d.translate(tx, ty);
            g2d.scale(sx, sy);
            g2d.drawRenderedImage(srcImage, null);
            g2d.setTransform(xform);
        }



        public BufferedImage serviceRequest(URL url) throws IOException
        {
            if (url == null)
            {
                String message = Logging.getMessage("nullValue.URLIsNull");
                Logging.logger().severe(message);
                throw new IllegalArgumentException(message);
            }

            AVList params = new AVListImpl();
            // Extract query parameters from the URL, placing them in the AVList.
            String query = url.getQuery();
            if (query != null)
            {
                String[] pairs = query.split("&");
                for (String s : pairs)
                {
                    String[] keyvalue = s.split("=", 2);
                    if (keyvalue != null && keyvalue.length == 2)
                        params.setValue(keyvalue[0], keyvalue[1]);
                }
            }
            // Convert parameter values to the appropriate type.
            initParams(params);

            return serviceRequest(params);
        }

        /**
         * Determines whether the constructor arguments are valid.
         *
         * @param params the list of parameters to validate.
         * @return null if valid, otherwise a <code>String</code> containing a description of why it's invalid.
         */
        private String validate(AVList params)
        {
            StringBuffer sb = new StringBuffer();

            Object o = params.getValue(BBOX);
            if (o == null || !(o instanceof Sector))
                sb.append("bounding box");

            o = params.getValue(WIDTH);
            if (o == null || !(o instanceof Integer) || ((Integer) o) < 1)
                sb.append("width");

            o = params.getValue(HEIGHT);
            if (o == null || !(o instanceof Integer) || ((Integer) o) < 1)
                sb.append("height");

            if (sb.length() == 0)
                return null;

            return "Inavlid RPFGenerator service request fields: " + sb.toString();
        }

        private AVList initParams(AVList params)
        {
            String s = params.getStringValue(BBOX);
            if (s != null)
            {
                String[] values = s.split(",");
                if (values != null && values.length == 4)
                {
                    try
                    {
                        // Bounding box string is expected in WMS format: "minlon,minlat,maxlon,maxlat"
                        double minLon = Double.parseDouble(values[0]);
                        double minLat = Double.parseDouble(values[1]);
                        double maxLon = Double.parseDouble(values[2]);
                        double maxLat = Double.parseDouble(values[3]);
                        params.setValue(BBOX, Sector.fromDegrees(minLat, maxLat, minLon, maxLon));
                    }
                    catch (NumberFormatException e)
                    {
                        Logging.logger().log(java.util.logging.Level.WARNING, "Parameter conversion error", e);
                        params.setValue(BBOX, null);
                    }
                }
            }

            s = params.getStringValue(WIDTH);
            if (s != null)
            {
                try
                {
                    int value = Integer.parseInt(s);
                    params.setValue(WIDTH, value);
                }
                catch (NumberFormatException e)
                {
                    Logging.logger().log(java.util.logging.Level.WARNING, "Parameter conversion error", e);
                    params.setValue(WIDTH, null);
                }
            }

            s = params.getStringValue(HEIGHT);
            if (s != null)
            {
                try
                {
                    int value = Integer.parseInt(s);
                    params.setValue(HEIGHT, value);
                }
                catch (NumberFormatException e)
                {
                    Logging.logger().log(java.util.logging.Level.WARNING, "Parameter conversion error", e);
                    params.setValue(HEIGHT, null);
                }
            }

            return params;
        }

        //
        // Attempts to return the specified FrameFile as a BufferedImage. Returns null on failure.
        //
        private RPFFrameTransform.RPFImage[] getImageFromRPFSource(FrameFile frame)
        {
            try
            {
                File file = frame.rpfFile;
                RPFImageFile sourceFile = RPFImageFile.load(file);
                BufferedImage image = sourceFile.getBufferedImage();
                return frame.getFrameTransform().deproject(frame.getFrameNumber(), image);
            }
            catch (Exception e)
            {
                String message = "Exception while reading frame file: " + frame.rpfFile;
                Logging.logger().log(java.util.logging.Level.SEVERE, message, e);          
                RPFGenerator.this.markFrameFileAbsent(frame);
                return null;
            }
        }

        //
        // Attempts to reconstruct the given FrameFile as a BufferedImage from a WaveletEncoding.
        // Returns null if encoding does not exist or on any other failure.
        //
        private BufferedImage getImageFromWaveletEncoding(FrameFile frame, int resolution)
        {
            if (resolution <= 0)
                return null;

            try
            {
                WaveletCodec codec;
                if (resolution <= RPFGenerator.this.preloadRes)
                {
                    // Lazily load the wavelet up to "preload resolution".
                    if (frame.codec == null)
                    {
                        java.nio.ByteBuffer buffer = WWIO.readFileToBuffer(frame.waveletFile);
                        frame.codec = WaveletCodec.loadPartial(buffer, RPFGenerator.this.preloadRes);
                    }
                    codec = frame.codec;
                }
                else
                {
                    // Read wavelet file.
                    java.nio.ByteBuffer buffer = WWIO.readFileToBuffer(frame.waveletFile);
                    codec = WaveletCodec.loadPartial(buffer, resolution);
                }

                BufferedImage sourceImage = null;
                if (codec != null)
                    sourceImage = codec.reconstruct(resolution);

                return sourceImage;
            }
            catch (Exception e)
            {
                String message = "Exception while reading wavelet file: " + frame.waveletFile;
                Logging.logger().log(java.util.logging.Level.SEVERE, message, e);
                RPFGenerator.this.markFrameFileAbsent(frame);
                return null;
            }
        }
    }

    private void markFrameFileAbsent(FrameFile frame)
    {
        this.absentFrames.markResourceAbsent(frame.id);
    }

    private boolean isFrameFileAbsent(FrameFile frame)
    {
        return this.absentFrames.isResourceAbsent(frame.id);
    }

    @SuppressWarnings({"UnusedDeclaration"})
    private void unmarkFrameFileAbsent(FrameFile frame)
    {
        this.absentFrames.unmarkResourceAbsent(frame.id);
    }
}