Cartographie avec GeoTools

Map config = new HashMap();
config.put("url", file.toURL() );
 
DataStore dataStore = DataStoreFinder.getDataStore( config );

Map config = new HashMap();
config.put( PostgisDataStoreFactory.DBTYPE.key, "postgis" );        
config.put( PostgisDataStoreFactory.HOST.key, "127.0.0.1" );
config.put( PostgisDataStoreFactory.PORT.key, "5432" );        
config.put( PostgisDataStoreFactory.SCHEMA.key, "public" );
config.put( PostgisDataStoreFactory.DATABASE.key, "mabase" );
config.put( PostgisDataStoreFactory.USER.key, "user" );
config.put( PostgisDataStoreFactory.PASSWD.key, "mdp" );
DataStore dataStore = DataStoreFinder.getDataStore( config );

PostgisDataStoreFactory pdsf = new PostgisDataStoreFactory();
 
Param[] params = pdsf.getParametersInfo();
for(Param pm : params){
    //une description de la clé
    String desc = pm.description;
    //la clé
    String key = pm.key;
    //Vrai si cette clé est obligatoire
    boolean needed = pm.required;
    //un exemple de valeur possible
    Object value = pm.sample;
    //la classe nécessaire
    Class classe = pm.type;
}

private static final String GEOTIFF = ".tif";
private static final String BMP = ".bmp";
private static final String JPG = ".jpg";
private static final String JPEG = ".jpeg";
private static final String PNG = ".png";
 
/**
* return a gridcoverage for Raster file. Use a Map containing key "url"
* @param params 
* @return GridCoverage
*/
    public static GridCoverage getGridCoverage(Map params){
 
        GridCoverage cover = null;
 
        URL url = (URL) params.get("url");
 
        if (url != null) {
            String name = url.getFile().toLowerCase();
            File file = null;
 
            try {
                file = new File(url.toURI());
            } catch (URISyntaxException ex) {
                ex.printStackTrace();
            }
 
            if (file != null) {
                // try a geotiff gridcoverage
                if (name.endsWith(GEOTIFF)) {
 
                    try {
                        GeoTiffReader reader = new GeoTiffReader(file, new Hints(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.TRUE));
                        cover = (GridCoverage2D) reader.read(null);
                    } catch (DataSourceException ex) {
                        cover = null;
                        ex.printStackTrace();
                    }catch (IOException ex){
                        cover = null;
                        ex.printStackTrace();
                    }
                } 
                // try a world image file
                else if (name.endsWith(BMP) || name.endsWith(JPG) || name.endsWith(JPEG) || name.endsWith(PNG)) {
 
                    try {
                        WorldImageReader reader = new WorldImageReader(file);
                        cover = (GridCoverage2D) reader.read(null);
                    } catch (DataSourceException ex) {
                        cover = null;
                        ex.printStackTrace();
                    }catch (IOException ex){
                        cover = null;
                        ex.printStackTrace();
                    }
                }
            }
 
        }
 
        return cover;
    }

    private void explorer(MapLayer layer) throws IOException {
 
        FeatureType type = layer.getFeatureSource().getSchema();
 
        GeometryDescriptor geodesc = type.getDefaultGeometry();
        System.out.println("GEOM : " + geodesc.getName());
        System.out.println("GEOM : " + geodesc.getType().getBinding());
 
 
        Collection<PropertyDescriptor> properties = type.getProperties();
        Iterator<PropertyDescriptor> propertiesIte = properties.iterator();
 
        while (propertiesIte.hasNext()) {
            PropertyDescriptor oneProperty = propertiesIte.next();
            System.out.println(oneProperty.getName() + " : " + oneProperty.getType().getBinding());
        }
    }

    private void parcourir(MapLayer layer) throws IOException {
 
        FeatureCollection features = layer.getFeatureSource().getFeatures();
        FeatureIterator featuresIte = features.features();
 
        while (featuresIte.hasNext()) {
            SimpleFeature oneFeature = featuresIte.next();
 
            for (int i = 0,  max = oneFeature.getAttributeCount(); i < max; i++) {
                System.out.println(oneFeature.getAttribute(i));
            }
        }
    }

    private void modifier(MapLayer layer) throws IOException {
        FeatureStore store;
 
        // (1)
        FeatureCollection features = layer.getFeatureSource().getFeatures();
        SimpleFeature oneFeature = features.features().next();
 
        // (2)
        AttributeDescriptor oneAttribut = layer.getFeatureSource().getSchema().getAttribute("NB_VOIES");
 
        // (3)
        String value = "4";
 
 
        // (4)
        if (layer.getFeatureSource() instanceof FeatureStore) {
 
            store = (FeatureStore) layer.getFeatureSource();
            // (5)
            DefaultTransaction transaction = new DefaultTransaction("trans_maj");
            store.setTransaction(transaction);
 
            // (6)
            FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints());
            Filter filter = factory.id(Collections.singleton(factory.featureId(oneFeature.getID())));
 
            // (7)
            try {
                store.modifyFeatures(oneAttribut, value, filter);
                transaction.commit();
            } catch (IOException ex) {
                ex.printStackTrace();
                try {
                    transaction.rollback();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }finally{
                transaction.close();
            }
        }
    }

    private void ajouter(MapLayer layer) {
        FeatureStore store;
 
        // (1)
        GeometryFactory geoFactory = new GeometryFactory();
 
        // (2)
        Coordinate coord1 = new Coordinate(50, 430);
        Coordinate coord2 = new Coordinate(21, 712);
        LineString line = geoFactory.createLineString(new Coordinate[]{coord1, coord2});
        MultiLineString lines = geoFactory.createMultiLineString(new LineString[]{line});
 
        SimpleFeatureType featureType = layer.getFeatureSource().getSchema();
 
        // (3)
        Object[] values = new Object[featureType.getAttributeCount()];
 
        AttributeDescriptor geomAttribut = featureType.getDefaultGeometry();
        List<AttributeDescriptor> attributes = featureType.getAttributes();
 
        // (4) 
        for (int i = 0,  max = attributes.size(); i < max; i++) {
            AttributeDescriptor oneAttribut = attributes.get(i);
 
            // (5) 
            if (oneAttribut.equals(geomAttribut)) {
                values[i] = lines;
            } else {
                values[i] = oneAttribut.getDefaultValue();
            }
        }
 
        // (6) 
        SimpleFeature myFeature = SimpleFeatureBuilder.build(featureType, values, null);
 
        // (7) 
        FeatureCollection lstFeatures = FeatureCollections.newCollection();
        lstFeatures.add(myFeature);
 
        // (8) 
        if (layer.getFeatureSource() instanceof FeatureStore) {
            store = (FeatureStore) layer.getFeatureSource();
 
            DefaultTransaction transaction = new DefaultTransaction();
            store.setTransaction(transaction);
 
            // (9)
            try {
                store.addFeatures(lstFeatures);
                transaction.commit();                
            } catch (Exception ex) {
                ex.printStackTrace();
                try {
                    store.getTransaction().rollback();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }finally{
                transaction.close();
            }
 
        }
 
    }

        FeatureStore store;
 
        // (1)
        FeatureCollection features = layer.getFeatureSource().getFeatures();
        SimpleFeature oneFeature = features.features().next();
 
        // (2)
        if (layer.getFeatureSource() instanceof FeatureStore) {
 
            store = (FeatureStore) layer.getFeatureSource();
            // (3)
            DefaultTransaction transaction = new DefaultTransaction("trans_maj");
            store.setTransaction(transaction);
 
            // (4)
            FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints());
            Filter filter = factory.id(Collections.singleton(factory.featureId(oneFeature.getID())));
 
            // (5)
            try {
                store.removeFeatures(filter);
                transaction.commit();
            } catch (IOException ex) {
                ex.printStackTrace();
                try {
                    transaction.rollback();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }finally{
                transaction.close();
            }
        }
    }

//liste des panneaux visibles
List<DataPanel> lst = new ArrayList<DataPanel>();
lst.add(new JFileDataPanel());
lst.add(new JDatabaseDataPanel());
 
JDataChooser jdc = new JDataChooser(null,lst);            
JDataChooser.ACTION ret = jdc.showDialog();
 
if (ret == JDataChooser.ACTION.APPROVE) {
    //tous les MapLayers correspondants aux fichiers/tables sélectionnés.
    List<MapLayer> layers = jdc.getLayers();
    }

if (layer.getFeatureSource().getSchema().getTypeName().equals("GridCoverage")) {
    System.out.println("Layer de type raster");
}else{
    System.out.println("Layer de type vecteur");
}

import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.MultiLineString;
import com.vividsolutions.jts.geom.MultiPolygon;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.MultiPoint;
import com.vividsolutions.jts.geom.Polygon;
 
 
Class jtsClass = layer.getFeatureSource().getSchema().getDefaultGeometry().getType().getBinding();
 
if (jtsClass.equals(Point.class)) {
    System.out.println("Geometrie de type POINT");
} else if (jtsClass.equals(MultiPoint.class)) {
    System.out.println("Geometrie de type MULTI-POINT");
 } else if (jtsClass.equals(LineString.class)) {
    System.out.println("Geometrie de type LIGNE");
} else if (jtsClass.equals(MultiLineString.class)) {
    System.out.println("Geometrie de type MULTI-LIGNE");
} else if (jtsClass.equals(Polygon.class)) {
    System.out.println("Geometrie de type POLYGONE");
} else if (jtsClass.equals(MultiPolygon.class)) {
    System.out.println("Geometrie de type MULTI-POLYGONE");
}

if (layer.getFeatureSource() instanceof FeatureStore) {
    FeatureStore store = (FeatureStore) layer.getFeatureSource();  
    System.out.println("Ce layer est éditable");
}else{
    System.out.println("Ce layer n'est pas éditable");
}