rubbersheetimage.java

world wind java sdk 源码

            {
                if (entry != selected)
                {
                    if (entry.getEditor().isArmed())
                    {
                        entry.getEditor().setArmed(false);
                    }
                }
            }

            if (!selected.getEditor().isArmed())
            {
                selected.getEditor().setArmed(true);
            }
        }

        protected void doOpenImageFile()
        {
            if (this.openFileChooser == null)
            {
                this.openFileChooser = new JFileChooser(Configuration.getUserHomeDirectory());
                this.openFileChooser.setAcceptAllFileFilterUsed(false);
                this.openFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                this.openFileChooser.setMultiSelectionEnabled(true);
                this.openFileChooser.addChoosableFileFilter(new ImageIOFileFilter(this.imageReader));
            }

            int retVal = this.openFileChooser.showOpenDialog(this.appFrame);
            if (retVal != JFileChooser.APPROVE_OPTION)
                return;

            File[] files = this.openFileChooser.getSelectedFiles();
            this.loadFiles(files);
        }

        protected void doSetImageOpacity(double opacity)
        {
            for (SurfaceImageEntry entry : this.entryList)
            {
                entry.getSurfaceImage().setOpacity(opacity);
            }

            this.appFrame.getWwd().redraw();
        }

        protected void loadBackgroundData()
        {
            DataDescriptor dataDescriptor = findDataDescriptor("Mercury_Orthophoto_2007");
            if (dataDescriptor != null)
            {
                TiledImageLayer layer = new BasicTiledImageLayer(dataDescriptor);
                layer.setName(dataDescriptor.getName());
                layer.setUseTransparentTextures(true);
                insertBeforePlacenames(this.appFrame.getWwd(), layer);

                this.appFrame.getLayerPanel().update(this.appFrame.getWwd());
            }
        }

        protected void loadFiles(final File[] files)
        {
            this.appFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

            Thread thread = new Thread(new Runnable()
            {
                public void run()
                {
                    for (File f : files)
                    {
                        loadFile(f);
                    }

                    appFrame.setCursor(null);
                }
            });
            thread.start();
        }

        protected void loadFile(File file)
        {
            try
            {
                java.awt.image.BufferedImage image = this.imageReader.read(file);
                SurfaceImage si = null;

                File tabFile = this.getAssociatedTABFile(file);
                if (tabFile != null)
                    si = this.createSurfaceImageFromTABFile(image, tabFile);

                if (si == null)
                {
                    File gcpsFile = this.getAssociatedGCPSFile(file);
                    if (gcpsFile != null)
                        si = this.createSurfaceImageFromGCPSFile(image, gcpsFile);
                }

                if (si == null)
                {
                    File[] worldFiles = this.getAssociatedWorldFiles(file);
                    if (worldFiles != null)
                        si = this.createSurfaceImageFromWorldFiles(image, worldFiles);
                }

                if (si == null)
                {
                    StringBuilder message = new StringBuilder();
                    message.append("Unable to find geographic coordinates for: ");
                    message.append("\"").append(file.getPath()).append("\"");
                    message.append("\n");
                    message.append("Open image anyway?");

                    int retVal = JOptionPane.showConfirmDialog(this.appFrame, message, null, JOptionPane.YES_NO_OPTION);
                    if (retVal == JOptionPane.YES_OPTION)
                    {
                        si = this.createSurfaceImageFromViewport(image, this.appFrame.getWwd());
                    }
                }

                if (si != null)
                {
                    this.addSurfaceImage(si, file.getName());
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }

        public File getAssociatedTABFile(File file)
        {
            File tabFile = TABRasterReader.getTABFileFor(file);
            if (tabFile != null && tabFile.exists())
            {
                TABRasterReader reader = new TABRasterReader();
                if (reader.canRead(tabFile))
                    return tabFile;
            }

            return null;
        }

        public File getAssociatedGCPSFile(File file)
        {
            File gcpsFile = GCPSReader.getGCPSFileFor(file);
            if (gcpsFile != null && gcpsFile.exists())
            {
                GCPSReader reader = new GCPSReader();
                if (reader.canRead(gcpsFile))
                    return gcpsFile;
            }

            return null;
        }

        public File[] getAssociatedWorldFiles(File file)
        {
            try
            {
                File[] worldFiles = WorldFile.getWorldFiles(file);
                if (worldFiles != null && worldFiles.length > 0)
                    return worldFiles;
            }
            catch (Exception ignored)
            {
            }

            return null;
        }

        protected SurfaceImage createSurfaceImageFromWorldFiles(java.awt.image.BufferedImage image, File[] worldFiles)
            throws java.io.IOException
        {
            AVList worldFileParams = new AVListImpl();
            WorldFile.decodeWorldFiles(worldFiles, worldFileParams);
            
            BufferedImage alignedImage = new BufferedImage(image.getWidth(), image.getHeight(),
                BufferedImage.TYPE_INT_ARGB);
            Sector sector = ImageUtil.warpImageWithWorldFile(image, worldFileParams, alignedImage);

            return new SurfaceImage(alignedImage, sector);
        }

        protected SurfaceImage createSurfaceImageFromTABFile(java.awt.image.BufferedImage image, File tabFile)
            throws java.io.IOException
        {
            TABRasterReader reader = new TABRasterReader();
            RasterControlPointList controlPoints = reader.read(tabFile);

            return this.createSurfaceImageFromControlPoints(image, controlPoints);
        }

        protected SurfaceImage createSurfaceImageFromGCPSFile(java.awt.image.BufferedImage image, File gcpsFile)
            throws java.io.IOException
        {
            GCPSReader reader = new GCPSReader();
            RasterControlPointList controlPoints = reader.read(gcpsFile);

            return this.createSurfaceImageFromControlPoints(image, controlPoints);
        }

        protected SurfaceImage createSurfaceImageFromControlPoints(java.awt.image.BufferedImage image,
            RasterControlPointList controlPoints) throws java.io.IOException
        {
            int numControlPoints = controlPoints.size();
            Point2D[] imagePoints = new Point2D[numControlPoints];
            LatLon[] geoPoints = new LatLon[numControlPoints];

            for (int i = 0; i < numControlPoints; i++)
            {
                RasterControlPointList.ControlPoint p = controlPoints.get(i);
                imagePoints[i] = p.getRasterPoint();
                geoPoints[i] = p.getWorldPointAsLatLon();
            }

            BufferedImage destImage = new BufferedImage(image.getWidth(), image.getHeight(),
                BufferedImage.TYPE_INT_ARGB);
            Sector sector = ImageUtil.warpImageWithControlPoints(image, imagePoints, geoPoints, destImage);

            return new SurfaceImage(destImage, sector);
        }

        protected SurfaceImage createSurfaceImageFromViewport(java.awt.image.BufferedImage image, WorldWindow wwd)
        {
            Position position = ShapeUtils.getNewShapePosition(wwd);
            Angle heading = ShapeUtils.getNewShapeHeading(wwd, false);
            double sizeInMeters = ShapeUtils.getViewportScaleFactor(wwd);

            java.util.List<LatLon> corners = ShapeUtils.createSquareInViewport(wwd, position, heading, sizeInMeters);

            return new SurfaceImage(image, corners);
        }
    }

    protected static DataDescriptor findDataDescriptor(String name)
    {
        for (File file : WorldWind.getDataFileStore().getLocations())
        {
            if (!WorldWind.getDataFileStore().isInstallLocation(file.getPath()))
                continue;

            for (DataDescriptor dataDescriptor : WorldWind.getDataFileStore().findDataDescriptors(file.getPath()))
            {
                if (dataDescriptor.getName().equals(name))
                    return dataDescriptor;
            }
        }

        return null;
    }

    public static void main(String[] args)
    {
        ApplicationTemplate.start("World Wind Rubber Sheet Image", RubberSheetImage.AppFrame.class);
    }
}