Ignore:
Timestamp:
2011-08-05T09:22:17+02:00 (13 years ago)
Author:
bastik
Message:

fixed a couple of bugs (see josm ticket 6665)

Location:
applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin/ImageLayer.java

    r26413 r26452  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.awt.Component;
    6 import java.awt.Color;
    75import java.awt.Graphics2D;
    86import java.awt.Image;
    … …  
    1715import javax.swing.Icon;
    1816import javax.swing.ImageIcon;
    19 import javax.swing.JMenuItem;
    20 import javax.swing.JOptionPane;
    21 import javax.swing.JSeparator;
    2217
    2318import org.apache.log4j.Logger;
    … …  
    3631import org.openstreetmap.josm.data.coor.LatLon;
    3732import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     33import org.openstreetmap.josm.gui.ExtendedDialog;
    3834import org.openstreetmap.josm.gui.MapView;
    3935import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
    … …  
    4339/**
    4440 *  Layer which contains spatial referenced image data.
    45  * 
     41 *
    4642 * @author Christoph Beekmans, Fabian Kowitz, Anna Robaszkiewicz, Oliver Kuhn, Martin Ulitzny
    4743 *
    … …  
    5248
    5349    private File imageFile;
    54    
     50
    5551    private BufferedImage image = null;
    5652
    … …  
    6258    // current bbox
    6359    private Envelope2D bbox;
    64    
     60
    6561    // Layer icon
    6662    private Icon layericon = null;
    67    
     63
    6864    // reference system of the oringinal image
    6965    private CoordinateReferenceSystem sourceRefSys;
    … …  
    7167    /**
    7268     * Constructor
    73      * 
     69     *
    7470     * @param file
    75      * @throws IOException 
     71     * @throws IOException
    7672     */
    7773    public ImageLayer(File file) throws IOException {
    7874        super(file.getName());
    79        
     75
    8076        this.imageFile = file;
    8177        this.image = (BufferedImage) createImage();
    … …  
    8581    /**
    8682     * create spatial referenced image.
    87      * 
     83     *
    8884     * @return
    8985     * @throws IOException
    … …  
    9793            coverage = PluginOperations.createGridFromFile(imageFile, null, true);
    9894            this.sourceRefSys = coverage.getCoordinateReferenceSystem();
    99            
     95
    10096            // now reproject grid coverage
    101             coverage = PluginOperations.reprojectCoverage(coverage, CRS.decode(Main.proj.toCode()));
    102        
     97            coverage = PluginOperations.reprojectCoverage(coverage, CRS.decode(Main.getProjection().toCode()));
     98
    10399        } catch (FactoryException e) {
    104100            logger.error("Error while creating GridCoverage:",e);
    … …  
    107103            if(e.getMessage().contains("No projection file found"))
    108104            {
    109                 int useUnprojected = JOptionPane.showConfirmDialog(Main.parent, "<html>No projection file (.prj) found.<br />Use the image unprojected?</html>", "Missing projection", JOptionPane.YES_NO_OPTION);
    110                 if (useUnprojected == 0) { // Yes
    111                     logger.debug("Passing through image un-projected.");
    112                     try {
    113                         // create a grid coverage from the image
    114                         coverage = PluginOperations.createGridFromFile(imageFile, null, false);
    115                         this.sourceRefSys = coverage.getCoordinateReferenceSystem();
    116                     } catch (Exception e1) {
    117                         logger.error("Error while creating GridCoverage:",e1);
    118                         throw new IOException(e1);
    119                     }
    120                 } else { // No
     105                ExtendedDialog ex = new ExtendedDialog(Main.parent, tr("Warning"), new String[] {tr("Default image projection"), tr("JOSM's current projection"), tr("Cancel")});
     106                ex.setContent(tr("No projection file (.prj) found.<br>"
     107                        + "You can choose the default image projection ({0}) or JOSM''s current editor projection ({1}) as original image projection.<br>"
     108                        + "(It can be changed later from the right click menu of the image layer.)",
     109                        ImportImagePlugin.pluginProps.getProperty("default_crs_srid"), Main.getProjection().toCode()));
     110                ex.showDialog();
     111                int val = ex.getValue();
     112                if (val == 3) {
    121113                    logger.debug("No projection and user declined un-projected use");
    122114                    throw new LayerCreationCancledException();
     115                }
     116                CoordinateReferenceSystem src = null;
     117                try {
     118                    if (val == 1) {
     119                        src = PluginOperations.defaultSourceCRS;
     120                    } else {
     121                        logger.debug("Passing through image un-projected.");
     122                        src = CRS.decode(Main.getProjection().toCode());
     123                    }
     124                    // create a grid coverage from the image
     125                    coverage = PluginOperations.createGridFromFile(imageFile, src, false);
     126                    this.sourceRefSys = coverage.getCoordinateReferenceSystem();
     127                    if (val == 1) {
     128                        coverage = PluginOperations.reprojectCoverage(coverage, CRS.decode(Main.getProjection().toCode()));
     129                    }
     130                } catch (Exception e1) {
     131                    logger.error("Error while creating GridCoverage:",e1);
     132                    throw new IOException(e1);
    123133                }
    124134            }
    … …  
    171181            // Rotate image by angle
    172182            g.rotate(angle * Math.PI / 180.0);
    173            
     183
    174184            // Determine scale to fit JOSM extents
    175185            ProjectionBounds projbounds = Main.map.mapView
    … …  
    199209            // Draw picture
    200210            g.drawImage(image, 0, 0, null);
    201            
     211
    202212        } else {
    203213            logger.error("Error while dawing image: image == null or Graphics == null");
    204214        }
    205215    }
    206    
     216
    207217    public Envelope2D getBbox() {
    208218        return bbox;
    … …  
    236246    @Override
    237247    public boolean isMergable(Layer arg0) {
    238         // TODO Auto-generated method stub
    239248        return false;
    240249    }
    … …  
    242251    @Override
    243252    public void mergeFrom(Layer arg0) {
    244         // TODO Auto-generated method stub
    245 
    246     }
    247 
    248     @Override
    249     public void visitBoundingBox(BoundingXYVisitor arg0) {
    250         // TODO Auto-generated method stub
    251     }
    252    
     253        throw new UnsupportedOperationException();
     254    }
     255
     256    @Override
     257    public void visitBoundingBox(BoundingXYVisitor visitor) {
     258            EastNorth min = new EastNorth(getBbox().getMinX(), getBbox().getMinY());
     259            EastNorth max = new EastNorth(getBbox().getMaxX(), getBbox().getMaxY());
     260            visitor.visit(min);
     261            visitor.visit(max);
     262    }
    253263
    254264    @Override
    … …  
    257267        return this.getName();
    258268    }
    259    
     269
    260270
    261271    public File getImageFile() {
    … …  
    266276        return image;
    267277    }
    268    
     278
    269279    /**
    270280     * loads the image and reprojects it using a transformation
    271281     * calculated by the new reference system.
    272      * 
     282     *
    273283     * @param newRefSys
    274      * @throws IOException 
    275      * @throws FactoryException 
    276      * @throws NoSuchAuthorityCodeException 
     284     * @throws IOException
     285     * @throws FactoryException
     286     * @throws NoSuchAuthorityCodeException
    277287     */
    278288    void resample(CoordinateReferenceSystem refSys) throws IOException, NoSuchAuthorityCodeException, FactoryException
    … …  
    280290        logger.debug("resample");
    281291        GridCoverage2D coverage =  PluginOperations.createGridFromFile(this.imageFile, refSys, true);
    282         coverage = PluginOperations.reprojectCoverage(coverage, CRS.decode(Main.proj.toCode()));
     292        coverage = PluginOperations.reprojectCoverage(coverage, CRS.decode(Main.getProjection().toCode()));
    283293        this.bbox = coverage.getEnvelope2D();
    284294        this.image = ((PlanarImage)coverage.getRenderedImage()).getAsBufferedImage();
    285        
    286         // TODO
    287         upperLeft = new EastNorth(coverage.getEnvelope2D().y, coverage
    288                 .getEnvelope2D().x
    289                 + coverage.getEnvelope2D().width);
     295
     296        upperLeft = new EastNorth(coverage.getEnvelope2D().x, coverage
     297                .getEnvelope2D().y
     298                + coverage.getEnvelope2D().height);
    290299        angle = 0;
    291300
    292301        // repaint and zoom to new bbox
    293         Main.map.mapView.repaint();
    294         LatLon min = new LatLon(bbox.getMinX(), bbox.getMinY());
    295         LatLon max = new LatLon(bbox.getMaxX(), bbox.getMaxY());
    296         Main.map.mapView.zoomTo(new Bounds(min, max));
    297        
    298        
    299     }
    300    
     302        BoundingXYVisitor boundingXYVisitor = new BoundingXYVisitor();
     303        visitBoundingBox(boundingXYVisitor);
     304        Main.map.mapView.recalculateCenterScale(boundingXYVisitor);
     305    }
     306
    301307    /**
    302308     * Action that creates a dialog GUI element with properties of a layer.
    303      * 
     309     *
    304310     */
    305311    public class LayerPropertiesAction extends AbstractAction
    306312    {
    307313        public ImageLayer imageLayer;
    308        
     314
    309315        public LayerPropertiesAction(ImageLayer imageLayer){
    310316            super(tr("Layer Properties"));
    … …  
    313319
    314320        public void actionPerformed(ActionEvent arg0) {
    315            
     321
    316322            LayerPropertiesDialog layerProps = new LayerPropertiesDialog(imageLayer, PluginOperations.crsDescriptions);
    317323            layerProps.setLocation(Main.parent.getWidth() / 4 , Main.parent.getHeight() / 4);
    318324            layerProps.setVisible(true);
    319325        }
    320        
    321     }
    322    
     326
     327    }
     328
    323329    /**
    324330     * Exception which represents that the layer creation has been cancled by the
    … …  
    328334    class LayerCreationCancledException extends IOException{
    329335    }
    330    
     336
    331337    public CoordinateReferenceSystem getSourceRefSys() {
    332338        return sourceRefSys;

  • applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin/ImportImagePlugin.java

    r23305 r26452  
    2525 * Plugin class.
    2626 * Provides basic routines for plugin installation and provides the plugin properties.
    27  * 
    28  * 
     27 *
     28 *
    2929 * @author Christoph Beekmans, Fabian Kowitz, Anna Robaszkiewicz, Oliver Kuhn, Martin Ulitzny
    3030 *
    3131 */
    3232public class ImportImagePlugin extends Plugin{
    33    
     33
    3434    private static Logger logger;
    35    
     35
    3636    JMenu mainmenu = null;
    3737    JosmAction loadFileAction = null;
    38    
     38
    3939    // custom Classloader
    4040    static ClassLoader pluginClassLoader;
    41    
     41
    4242    // plugin proerties
    4343    static Properties pluginProps;
    44    
     44
    4545    // path constants
    4646    static final String PLUGIN_DIR = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/";
    47     static final String PLUGINPROPERTIES_PATH = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/pluginProperties.properties"; 
    48     static final String PLUGINLIBRARIES_DIR = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/lib/"; 
     47    static final String PLUGINPROPERTIES_PATH = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/pluginProperties.properties";
     48    static final String PLUGINLIBRARIES_DIR = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/lib/";
    4949    static final String PLUGINPROPERTIES_FILENAME = "pluginProperties.properties";
    5050    static final String LOGGING_PROPERTIES_FILEPATH = Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/log4j.properties/";
    51    
    52    
     51
     52
    5353    public Properties getPluginProps() {
    5454        return pluginProps;
    … …  
    5858    /**
    5959     * constructor
    60      * 
     60     *
    6161     * @param info
    6262     */
    6363    public ImportImagePlugin(PluginInformation info){
    6464        super(info);
    65        
     65
     66        // switch to x=lon and y=lat for EPSG:4326 as JOSM does
     67        // (formally incorrect, but reasonable)
     68        System.setProperty("org.geotools.referencing.forceXY", "true");
     69
    6670        try {
    67            
     71
    6872            // First create custom ClassLoader to load resources from the main JAR
    6973            pluginClassLoader = createPluginClassLoader();
    70            
     74
    7175            // Initialize logger
    7276            initializeLogger(pluginClassLoader);
    73            
     77
    7478            // Check whether plugin has already been installed. Otherwise install
    7579            checkInstallation();
    76            
     80
    7781            // If resources are available load properties from plugin directory
    7882            if(pluginProps == null || pluginProps.isEmpty())
    … …  
    97101                method.invoke(sysLoader, new Object[]{library.toURI().toURL()});
    98102            }
    99            
    100            
     103
     104
    101105            // load information about supported reference systems
    102106            PluginOperations.loadCRSData(pluginProps);
    103            
     107
    104108            // create new Action for menu entry
    105109            LoadImageAction loadFileAction = new LoadImageAction();
    106110            loadFileAction.setEnabled(true);
    107            
     111
    108112            // add menu entries
    109113            Main.main.menu.fileMenu.insert(loadFileAction, 8);
    110114            Main.main.menu.fileMenu.insertSeparator(9);
    111            
     115
    112116
    113117        } catch (Exception e) {
    … …  
    121125
    122126        logger.info("Plugin successfully loaded.");
    123        
    124     }
    125 
    126    
    127    
     127
     128    }
     129
    128130    /**
    129131     * Checks whether plugin resources are available.
    130132     * If not, start install procedure.
    131      * 
     133     *
    132134     * @throws IOException
    133135     */
    134136    private void checkInstallation() throws IOException
    135137    {
    136        
     138
    137139        // check plugin resource state
    138140        boolean isInstalled = true;
    … …  
    141143                || !new File(PLUGINLIBRARIES_DIR).exists())
    142144            isInstalled = false;
    143        
    144        
     145
     146
    145147        // if properties file doesn't exist, install plugin
    146148        if(!isInstalled)
    147149        {
    148            
     150
    149151            /*----------- Begin installation ---------------*/
    150            
     152
    151153            // check if plugin directory exist
    152154            File pluginDir = new File(PLUGIN_DIR);
    … …  
    154156                pluginDir.mkdir();
    155157            }
    156            
     158
    157159            // check if "lib" directory exist
    158160            File libDir = new File(PLUGINLIBRARIES_DIR);
    … …  
    160162                libDir.mkdir();
    161163            }
    162            
     164
    163165            // create local properties file
    164166            if(pluginProps == null || pluginProps.isEmpty()){
    165                
     167
    166168                FileWriter fw = new FileWriter(new File(PLUGINPROPERTIES_PATH));
    167169                URL propertiesURL = pluginClassLoader.getResource("resources/" + PLUGINPROPERTIES_FILENAME);
    … …  
    172174                logger.debug("Plugin properties loaded");
    173175            }
    174            
     176
    175177            if(!new File(LOGGING_PROPERTIES_FILEPATH).exists())
    176178            {
    … …  
    184186            }
    185187
    186            
    187             // Copy all needed JAR files to $PLUGIN_DIR$/lib/ 
     188
     189            // Copy all needed JAR files to $PLUGIN_DIR$/lib/
    188190            String[] libStrings = pluginProps.getProperty("libraries").split(",");
    189            
     191
    190192            for (int i = 0; i < libStrings.length; i++) {
    191                
     193
    192194                URL url = pluginClassLoader.getResource("lib/" + libStrings[i]);
    193                
     195
    194196                FileOutputStream out = null;
    195                
     197
    196198                try{
    197199                    out = new FileOutputStream(new File(libDir, libStrings[i]));
    … …  
    199201                    break;
    200202                }
    201                
     203
    202204                BufferedInputStream in = null;
    203205                try
    … …  
    227229    /**
    228230     * Initialize logger using plugin classloader.
    229      * 
     231     *
    230232     * @param cl
    231233     */
    … …  
    235237        try {
    236238            props.load(new File(LOGGING_PROPERTIES_FILEPATH).toURI().toURL().openStream());
    237            
     239
    238240            // Set file for logging here:
    239241            props.setProperty("log4j.appender.MyRoFiAppender.file",
    240242                    (Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/" + "log.log"));
    241            
     243
    242244            PropertyConfigurator.configure(props);
    243245
    244246            logger = Logger.getLogger(ImportImagePlugin.class);
    245            
     247
    246248            logger.info("Logger successfully initialized.");
    247            
     249
    248250            return;
    249        
     251
    250252        } catch (IOException e) {
    251253            System.out.println("Logging properties file not found. Using standard settings.");
    252254        }
    253        
     255
    254256        // if no log4j.properties file can be found, initialize manually:
    255        
     257
    256258        props.setProperty("log4j.rootLogger", "INFO, A");
    257259        props.setProperty("log4j.appender.A", "org.apache.log4j.FileAppender");
    … …  
    265267        props.setProperty("log4j.appender.A.file",
    266268                (Main.pref.getPluginsDirectory().getAbsolutePath() + "/ImportImagePlugin/" + "log.log"));
    267        
     269
    268270        PropertyConfigurator.configure(props);
    269271        logger = Logger.getLogger(ImportImagePlugin.class);
    270272        logger.info("Logger successfully initialized with standard settings.");
    271        
    272     }
    273    
     273
     274    }
     275
    274276    /**
    275277     * get a plugin-specific classloader.
    276      * 
     278     *
    277279     * @return
    278      * @throws MalformedURLException 
    279      */
    280     private ClassLoader createPluginClassLoader() throws MalformedURLException 
     280     * @throws MalformedURLException
     281     */
     282    private ClassLoader createPluginClassLoader() throws MalformedURLException
    281283    {
    282284        ClassLoader loader = null;
    … …  
    285287                ImportImagePlugin.class.getClassLoader()
    286288                );
    287        
     289
    288290        return loader;
    289291    }
    290    
     292
    291293}

  • applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin/LayerPropertiesDialog.java

    r23305 r26452  
    565565            eastingFirstCheckBox = new JCheckBox();
    566566            eastingFirstCheckBox.setBounds(new Rectangle(345, 255, 21, 21));
     567            eastingFirstCheckBox.setSelected(true);
    567568        }
    568569        return eastingFirstCheckBox;

  • applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin/LoadImageAction.java

    r26413 r26452  
    11package org.openstreetmap.josm.plugins.ImportImagePlugin;
    22import java.awt.event.ActionEvent;
    3 import java.io.IOException;
    43
    54import javax.swing.JFileChooser;
    6 import javax.swing.JFrame;
    75import javax.swing.JOptionPane;
    86
    … …  
    1311import org.openstreetmap.josm.Main;
    1412import org.openstreetmap.josm.actions.JosmAction;
    15 import org.openstreetmap.josm.data.Bounds;
    16 import org.openstreetmap.josm.data.coor.EastNorth;
    1713import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    1814import org.openstreetmap.josm.plugins.ImportImagePlugin.ImageLayer.LayerCreationCancledException;
    … …  
    2117/**
    2218 * Class extends JosmAction and creates a new image layer.
    23  * 
     19 *
    2420 * @author Christoph Beekmans, Fabian Kowitz, Anna Robaszkiewicz, Oliver Kuhn, Martin Ulitzny
    2521 *
    2622 */
    2723public class LoadImageAction extends JosmAction {
    28    
     24
    2925    private Logger logger = Logger.getLogger(LoadImageAction.class);
    3026
    … …  
    3935
    4036        // Choose a file
    41         JFileChooser fc = new JFileChooser();
     37        JFileChooser fc = new JFileChooser(Main.pref.get("plugins.importimage.importpath", null));
    4238        fc.setAcceptAllFileFilterUsed(false);
    4339        int result = fc.showOpenDialog(Main.parent);
    44        
     40
    4541        ImageLayer layer = null;
    4642        if (result == JFileChooser.APPROVE_OPTION) {
     43            Main.pref.put("plugins.importimage.importpath", fc.getCurrentDirectory().getAbsolutePath());
    4744            logger.info("File choosen:" + fc.getSelectedFile());
    4845            try {
    … …  
    5552                JOptionPane.showMessageDialog(null, marktr("Error while creating image layer: " + e.getCause()));
    5653                return;
    57                
     54
    5855            }
    59            
     56
    6057            // Add layer:
    6158            Main.main.addLayer(layer);
    62             EastNorth min = new EastNorth(layer.getBbox().getMinX(), layer.getBbox().getMinY());
    63             EastNorth max = new EastNorth(layer.getBbox().getMaxX(), layer.getBbox().getMaxY());
    6459            BoundingXYVisitor boundingXYVisitor = new BoundingXYVisitor();
    65             boundingXYVisitor.visit(min);
    66             boundingXYVisitor.visit(max);
     60            layer.visitBoundingBox(boundingXYVisitor);
    6761            Main.map.mapView.recalculateCenterScale(boundingXYVisitor);
    6862        }

  • applications/editors/josm/plugins/ImportImagePlugin/src/org/openstreetmap/josm/plugins/ImportImagePlugin/PluginOperations.java

    r26413 r26452  
    4141/**
    4242 * Class provides methods for resampling operations, IO and stores important data.
    43  * 
     43 *
    4444 * @author Christoph Beekmans, Fabian Kowitz, Anna Robaszkiewicz, Oliver Kuhn, Martin Ulitzny
    4545 *
    … …  
    4848
    4949    private static final Logger logger = Logger.getLogger(PluginOperations.class);
    50    
     50
    5151    // contains descriptions of all available CRS
    5252    static Vector<String> crsDescriptions;
    5353
    54     // the standard native CRS of user images 
     54    // the standard native CRS of user images
    5555    static CoordinateReferenceSystem defaultSourceCRS;
    5656    // description of 'defaultSourceCRS'
    5757    static String defaultSourceCRSDescription;
    58    
    59    
    60    
     58
     59
     60
    6161    public static enum SUPPORTEDIMAGETYPES {
    62         tiff, tif, jpg, jpeg, bmp, png 
     62        tiff, tif, jpg, jpeg, bmp, png
    6363    }
    6464
    6565    public static enum POSTFIXES_WORLDFILE {
    66         wld, jgw, jpgw, pgw, pngw, tfw, tifw, bpw, bmpw, 
     66        wld, jgw, jpgw, pgw, pngw, tfw, tifw, bpw, bmpw,
    6767    };
    68    
     68
    6969    /**
    7070     * Reprojects a GridCoverage to a given CRS.
    71      * 
     71     *
    7272     * @param coverage
    7373     * @param targetCrs
    7474     * @return destination
    75      * @throws FactoryException 
    76      * @throws NoSuchAuthorityCodeException 
     75     * @throws FactoryException
     76     * @throws NoSuchAuthorityCodeException
    7777     */
    7878    public static GridCoverage2D reprojectCoverage(GridCoverage2D coverage,
    … …  
    8181        // TODO: add category for NO_DATA values in coverage (transparency in
    8282        // image)
    83        
     83
    8484        GridCoverage2D destination = null;
    8585
    … …  
    100100
    101101    /**
    102      * Creates a org.geotools.coverage.grid.GridCoverage2D from a given file. 
    103      * 
     102     * Creates a org.geotools.coverage.grid.GridCoverage2D from a given file.
     103     *
    104104     * @param file
    105105     * @return
    106      * @throws IOException 
     106     * @throws IOException
    107107     * @throws Exception
    108108     */
    … …  
    110110
    111111        GridCoverage2D coverage = null;
    112        
     112
    113113        if (!file.exists()) throw new FileNotFoundException("File not found.");
    114114
    … …  
    123123                || extension.equalsIgnoreCase(".tiff"))
    124124        {
    125            
     125
    126126            // try to read GeoTIFF:
    127127            try {
    … …  
    136136                throw new IOException(facte);
    137137            }
    138            
    139             // file is no GeoTiff, searching for Worldfile and projection file: 
     138
     139            // file is no GeoTiff, searching for Worldfile and projection file:
    140140            String[] postfixes = {"wld", "tfw", "tifw"};
    141141            // try to read Worldfile:
    … …  
    151151                throw new IOException("No Worldfile found.");
    152152            }
    153            
     153
    154154            if (refSys == null) {
    155155                // if no crs is delivered try to read projection file:
    … …  
    160160                }
    161161            }
    162            
     162
    163163            BufferedImage img = ImageIO.read(file);
    164            
     164
    165165            // create Envelope
    166166            double width = (double) (img.getWidth() * tfwReader.getXPixelSize());
    … …  
    169169            double lowerLeft_y = (double) tfwReader.getYULC() - height;
    170170            Envelope2D bbox = new Envelope2D(null, new Rectangle2D.Double(lowerLeft_x, lowerLeft_y, width, height));
    171            
     171
    172172            coverage = createGridCoverage(img, bbox, refSys);
    173            
    174         }
    175         //
     173        }
     174        //
    176175        else if (extension.equalsIgnoreCase(".jpg")
    177176                || extension.equalsIgnoreCase(".jpeg"))
    … …  
    187186            }
    188187            if (tfwReader == null) throw new IOException("No Worldfile found.");
    189            
     188
    190189            if (refSys == null) {
    191190                // if no crs is delivered try to read projection file:
    … …  
    196195                }
    197196            }
    198            
     197
    199198            BufferedImage img = ImageIO.read(file);
    200            
     199
    201200            // create Envelope
    202201            double width = (double) (img.getWidth() * tfwReader.getXPixelSize());
    … …  
    205204            double lowerLeft_y = (double) tfwReader.getYULC() - height;
    206205            Envelope2D bbox = new Envelope2D(null, new Rectangle2D.Double(lowerLeft_x, lowerLeft_y, width, height));
    207            
     206
    208207            coverage = createGridCoverage(img, bbox, refSys);
    209            
    210208        }
    211209        else if(extension.equalsIgnoreCase(".bmp"))
    … …  
    230228                }
    231229            }
    232            
     230
    233231            BufferedImage img = ImageIO.read(file);
    234            
     232
    235233            // create Envelope
    236234            double width = (double) (img.getWidth() * tfwReader.getXPixelSize());
    … …  
    239237            double lowerLeft_y = (double) tfwReader.getYULC() - height;
    240238            Envelope2D bbox = new Envelope2D(null, new Rectangle2D.Double(lowerLeft_x, lowerLeft_y, width, height));
    241            
     239
    242240            coverage = createGridCoverage(img, bbox, refSys);
    243241        }
    244242        else if(extension.equalsIgnoreCase(".png"))
    245243        {
    246            
     244
    247245            String[] postfixes = {"wld", "pgw", "pngw"};
    248246            // try to read Worldfile:
    … …  
    255253            }
    256254            if(tfwReader == null) throw new IOException("No Worldfile found.");
    257            
     255
    258256            if (refSys == null) {
    259257                // if no crs is delivered try to read projection file:
    … …  
    264262                }
    265263            }
    266            
     264
    267265            BufferedImage img = ImageIO.read(file);
    268            
     266
    269267            // create Envelope
    270268            double width = (double) (img.getWidth() * tfwReader.getXPixelSize());
    … …  
    273271            double lowerLeft_y = (double) tfwReader.getYULC() - height;
    274272            Envelope2D bbox = new Envelope2D(null, new Rectangle2D.Double(lowerLeft_x, lowerLeft_y, width, height));
    275            
     273
    276274            coverage = createGridCoverage(img, bbox, refSys);
    277275        }
    … …  
    283281        return coverage;
    284282    }
    285    
    286     /**
    287      * Searches for a projection file (.prj) with the same name of 'file' 
     283
     284    /**
     285     * Searches for a projection file (.prj) with the same name of 'file'
    288286     * tries to parse it.
    289      * 
    290      * 
     287     *
     288     *
    291289     * @param file image file, not the real world file (will be searched)
    292      * @return 
    293      * @throws IOException 
     290     * @return
     291     * @throws IOException
    294292     */
    295293    public static CoordinateReferenceSystem readPrjFile(File file) throws IOException
    296294    {
    297        
     295
    298296        CoordinateReferenceSystem refSys = null;
    299        
     297
    300298        String prjFilename = null;
    301299        int dotPos = file.getAbsolutePath().lastIndexOf(".");
    302300        prjFilename = file.getAbsolutePath().substring(0, dotPos) + ".prj";
    303        
     301
    304302        File prjFile = new File(prjFilename);
    305303        if (!prjFile.exists()) return null;
    306304        logger.debug("Loading .prj file: " + prjFile.getAbsolutePath());
    307        
     305
    308306        StringBuilder sb = new StringBuilder();
    309307        String content = null;
    … …  
    313311            sb.append(content);
    314312        }
    315        
     313
    316314        try {
    317315            refSys = CRS.parseWKT(sb.toString().trim());
    … …  
    319317            throw new IOException("Unable to parse prj-file: '" + prjFile.getName() + "'");
    320318        }
    321        
     319
    322320        return refSys;
    323        
    324     }
    325    
    326    
     321
     322    }
     323
     324
    327325    /**
    328326     * Method for external use.
    329      * 
     327     *
    330328     * @param img
    331329     * @param bbox
    … …  
    338336        return new GridCoverageFactory().create("", img, bbox);
    339337    }
    340    
     338
    341339    /**
    342340     * Method for reading a GeoTIFF file.
    343      * 
    344      * @param file 
     341     *
     342     * @param file
    345343     * @param refSys if delivered, the coverage will be forced to use this crs
    346344     * @return
    … …  
    359357        // dont't use the EPSG-Factory because of wrong behaviour
    360358        hints.put(Hints.CRS_AUTHORITY_FACTORY, CRS.getAuthorityFactory(true));
    361        
     359
    362360        GeoTiffReader reader = new GeoTiffReader(file, hints);
    363        
     361
    364362        coverage = (GridCoverage2D) reader.read(null);
    365        
     363
    366364        return coverage;
    367365    }
    368    
    369    
    370     /**
    371      * Loads CRS data from an EPSG database and creates descrptions for each one. 
    372      * 
     366
     367
     368    /**
     369     * Loads CRS data from an EPSG database and creates descrptions for each one.
     370     *
    373371     * @param pluginProps
    374372     * @throws Exception
    … …  
    377375    {
    378376        String defaultcrsString = pluginProps.getProperty("default_crs_srid");
    379        
     377
    380378        crsDescriptions = new Vector<String>();
    381379        Set<String> supportedCodes = CRS.getSupportedCodes("EPSG");
    382380        CRSAuthorityFactory fac = CRS.getAuthorityFactory(false);
    383        
     381
    384382        for (Iterator iterator = supportedCodes.iterator(); iterator.hasNext();) {
    385383            String string = (String) iterator.next();
    386384            try {
     385                if ("WGS84(DD)".equals(string)) {
     386                    continue;
     387                }
    387388                InternationalString desc = fac.getDescriptionText("EPSG:" + string);
    388389
    389390                String description = desc.toString() + " [-EPSG:" + string + "-]";
    390                
     391
    391392                crsDescriptions.add(description);
    392                
     393
    393394                if(defaultcrsString != null && defaultcrsString.equalsIgnoreCase("EPSG:" + string)){
    394395                    boolean isEastingFirst = Boolean.valueOf(pluginProps.getProperty("default_crs_eastingfirst"));
    … …  
    397398                }
    398399            } catch (NoSuchAuthorityCodeException e) {
    399                 if(!string.equalsIgnoreCase("WGS84(DD)")){
    400                     logger.error("Error while loading EPSG data: " + e.getMessage());
    401                 }
     400                logger.error("Error while loading EPSG data: " + e.getMessage());
    402401            } catch (FactoryException e) {
    403402                logger.error("Error while loading EPSG data: " + e.getMessage());
    … …  
    405404        }
    406405    }
    407    
     406
    408407}
Note: See TracChangeset for help on using the changeset viewer.