/[schmitzm]/trunk/src/skrueger/geotools/StyledFS.java
ViewVC logotype

Diff of /trunk/src/skrueger/geotools/StyledFS.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 169 by alfonx, Tue Jun 30 08:03:29 2009 UTC revision 1228 by alfonx, Wed Nov 3 20:44:16 2010 UTC
# Line 1  Line 1 
1  package skrueger.geotools;  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
3  import java.io.File;   *
4  import java.io.FileNotFoundException;   * This file is part of the SCHMITZM library - a collection of utility
5  import java.io.IOException;   * classes based on Java 1.6, focusing (not only) on Java Swing
6  import java.net.URL;   * and the Geotools library.
7  import java.util.Date;   *
8  import java.util.HashMap;   * The SCHMITZM project is hosted at:
9  import java.util.Map;   * http://wald.intevation.org/projects/schmitzm/
10  import java.util.Random;   *
11     * This program is free software; you can redistribute it and/or
12  import javax.swing.ImageIcon;   * modify it under the terms of the GNU Lesser General Public License
13  import javax.swing.JPanel;   * as published by the Free Software Foundation; either version 3
14     * of the License, or (at your option) any later version.
15  import org.apache.log4j.Logger;   *
16  import org.geotools.data.FeatureSource;   * This program is distributed in the hope that it will be useful,
17  import org.geotools.feature.AttributeType;   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  import org.geotools.gui.swing.ExceptionMonitor;   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  import org.geotools.styling.Style;   * GNU General Public License for more details.
20  import org.opengis.referencing.crs.CoordinateReferenceSystem;   *
21     * You should have received a copy of the GNU Lesser General Public License (license.txt)
22  import schmitzm.geotools.styling.StylingUtil;   * along with this program; if not, write to the Free Software
23  import skrueger.AttributeMetaData;   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24  import skrueger.i8n.Translation;   * or try this link: http://www.gnu.org/licenses/lgpl.html
25     *
26  import com.vividsolutions.jts.geom.Envelope;   * Contributors:
27     *     Martin O. J. Schmitz - initial API and implementation
28  /**   *     Stefan A. Tzeggai - additional utility classes
29   * This class enables a non Atlas context to use the Atlas LayerPanel   ******************************************************************************/
30   * {@link JPanel} as a {@link MapContextManagerInterface}  package skrueger.geotools;
31   *  
32   * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>  import java.io.File;
33   */  import java.io.IOException;
34  public class StyledFS implements StyledFeatureSourceInterface {  import java.net.URL;
35          private static final Logger LOGGER = Logger.getLogger(StyledFS.class);  import java.util.Date;
36    import java.util.Random;
37          private final FeatureSource fs;  
38    import javax.swing.ImageIcon;
39          /**  import javax.swing.JPanel;
40           * A unique ID which identifies the Layer in the Atlas. It's more important  
41           * than it should be ;-)  import org.apache.log4j.Logger;
42           */  import org.geotools.data.FeatureSource;
43          private String id;  import org.geotools.feature.FeatureCollection;
44    import org.geotools.feature.NameImpl;
45          private Style style;  import org.geotools.geometry.jts.ReferencedEnvelope;
46    import org.geotools.styling.Style;
47          private Translation title;  import org.opengis.feature.simple.SimpleFeature;
48    import org.opengis.feature.simple.SimpleFeatureType;
49          private Translation desc;  import org.opengis.feature.type.AttributeDescriptor;
50    import org.opengis.filter.Filter;
51          private File sldFile;  import org.opengis.referencing.crs.CoordinateReferenceSystem;
52    
53          private HashMap<Integer, AttributeMetaData> map;  import schmitzm.geotools.io.GeoImportUtil;
54    import schmitzm.geotools.styling.StylingUtil;
55          /**  import skrueger.AttributeMetadataImpl;
56           * This class enables a non Atlas context to use the Atlas LayerPanel  import skrueger.AttributeMetadataInterface;
57           * {@link JPanel} as a {@link MapContextManagerInterface}  import skrueger.i8n.Translation;
58           *  
59           * @param fs  import com.vividsolutions.jts.geom.Envelope;
60           *            {@link FeatureSource} that is beeing styled.  
61           *  /**
62           * @param sldFile   * This class enables a non Atlas context to use the Atlas LayerPanel
63           *            may be <code>null</code>. Otherwise the SLD {@link File} to   * {@link JPanel} as a {@link MapContextManagerInterface}
64           *            import and associate with this {@link StyledFS}   *
65           */   * @author <a href="mailto:[email protected]">Stefan Alfons Tzeggai</a>
66          public StyledFS(FeatureSource fs, File sldFile) {   *
67     *         TODO Rename to StyledShapefile
68                  this.fs = fs;   */
69                  id = StyledFS.class.getSimpleName()  public class StyledFS implements StyledFeatureSourceInterface {
70                                  + new Random(new Date().getTime()).nextInt(10000000);          private static final Logger LOGGER = Logger.getLogger(StyledFS.class);
71    
72                  this.sldFile = sldFile;          private final FeatureSource<SimpleFeatureType, SimpleFeature> fs;
73    
74                  if ((sldFile != null) && (sldFile.exists())) {          /** Caching the CRS of the layer **/
75                          try {          CoordinateReferenceSystem crs = null;
76                                  style = StylingUtil.loadSLD(sldFile)[0];  
77                          } catch (FileNotFoundException e) {          /**
78                                  LOGGER           * A unique ID which identifies the Layer in the Atlas. It's more important
79                                                  .debug("The SLD file passed was empty. Leaving the Style untouched. (We are in the constructor.. so its null");           * than it should be ;-)
80                          } catch (Exception e) {           */
81                                  LOGGER.warn("Reading SLD failed: " + sldFile, e);          final private String id;
82                          }  
83                  }          private Style style;
84                  title = new Translation();  
85                  title.fromOneLine(sldFile.getName());          private Translation title;
86    
87                  desc = new Translation();          private Translation desc;
88                  desc.fromOneLine(sldFile.getAbsolutePath());  
89          }          private File sldFile;
90    
91          public void dispose() {          /** A map of simple attribute names to their meta-data **/
92          }          private AttributeMetadataMap<AttributeMetadataImpl> attMap;
93    
94          /**          private Filter filter = Filter.INCLUDE;
95           * Returnes human readable {@link String} of the CRS natively used by this  
96           * {@link DpLayer}          /**
97           *           * This class enables a non Atlas context to use the Atlas LayerPanel
98           * If crs == null, it will call {@link #getGeoObject()}           * {@link JPanel} as a {@link MapContextManagerInterface}
99           *           *
100           */           * @param fs
101          public String getCRSString() {           *            {@link FeatureSource} that is beeing styled.
102                  if (getCrs() == null)           *
103                          return "CRS?";           * @param sldFile
104             *            may be <code>null</code>. Otherwise the SLD {@link File} to
105                  return getCrs().getName().getCode();           *            import and associate with this {@link StyledFS}
106          }           *
107             * @param id
108          public CoordinateReferenceSystem getCrs() {           *            <code>null</code> is allowed and will autogenerate an id
109                  return fs.getSchema().getDefaultGeometry().getCoordinateSystem();           */
110          }          public StyledFS(FeatureSource<SimpleFeatureType, SimpleFeature> fs,
111                            File sldFile, String id) {
112          public Translation getDesc() {  
113                  return desc;                  this.fs = fs;
114          }  
115                    if (id == null) {
116          public Envelope getEnvelope() {                          this.id = StyledFS.class.getSimpleName()
117                  try {                                          + new Random(new Date().getTime()).nextInt(10000000);
118                          return fs.getBounds();                  } else {
119                  } catch (IOException e) {                          this.id = id;
120                          e.printStackTrace();                  }
121                          return null;  
122                  }                  this.sldFile = sldFile;
123          }  
124                    // datei existiert, dann lesen
125          public FeatureSource getGeoObject() throws Exception {                  if (sldFile != null && sldFile.exists()) {
126                  return fs;                          try {
127          }                                  style = StylingUtil.loadSLD(sldFile)[0];
128                            } catch (Exception e) {
129          public String getId() {                                  LOGGER.warn("Reading SLD failed: " + sldFile, e);
130                  return id;                                  style = null;
131          }                          }
132                    }
133          public ImageIcon getImageIcon() {  
134                  return null;                  title = new Translation();
135          }                  desc = new Translation();
136    
137          public URL getInfoURL() {                  if (sldFile != null) {
138                  return null;                          title.fromOneLine(sldFile.getName());
139          }                          desc.fromOneLine(sldFile.getAbsolutePath());
140                    }
141          public Translation getKeywords() {  
142                  return null;          }
143          }  
144            public StyledFS(FeatureSource<SimpleFeatureType, SimpleFeature> fs) {
145          public Style getStyle() {                  this(fs, (File) null, null);
146                  return style;          }
147          }  
148            public StyledFS(FeatureSource<SimpleFeatureType, SimpleFeature> fs,
149          public Translation getTitle() {                          String id) {
150                  return title;                  this(fs, null, id);
151          }          }
152    
153          public boolean isDisposed() {          public void dispose() {
154                  return false;          }
155          }  
156            /**
157          /**           * Returns human readable {@link String} of the CRS natively used by this
158           * If true, this layer will not be shown in the legend. Default = false           * {@link DpLayer}
159           */           *
160          /**           * If CRS == null, it will call {@link #getGeoObject()}
161           *           *
162           * Killed by SK: 6. April 09: Ein Layer soll nicht generell auf           */
163           * verstecken/nicht verstecken gestellt werden können. Das sind          public String getCRSString() {
164           * Eigenschaften der Karte/MapContext, ebenso wie die Reihenfolge der Layer.                  if (getCrs() == null)
165           * Im Atlas verwaltet deshalb nun die Klasse skrueger.atlas.Map welche Layer                          return "CRS?";
166           * nicht in der Legende auftauchen sollen. Meines Wissens hat keiner bisher  
167           * die Funktion genutzt.                  return getCrs().getName().getCode();
168           *          }
169           * // public boolean isHideInLegend() { // return false; // }  
170           */          public CoordinateReferenceSystem getCrs() {
171                    if (crs == null) {
172          public void setDesc(Translation dec) {                          crs = fs.getSchema().getCoordinateReferenceSystem();
173                  this.desc = dec;                          if (crs == null) {
174          }  
175                                    crs = fs.getSchema().getGeometryDescriptor()
176          public void setImageIcon(ImageIcon icon) {                                                  .getCoordinateReferenceSystem();
177          }  
178                                    if (crs == null) {
179          public void setKeywords(Translation keywords) {                                          LOGGER.warn("Could not determine the CRS of " + getTitle()
180          }                                                          + ". Using default "
181                                                            + GeoImportUtil.getDefaultCRS());
182          public void setStyle(Style style) {                                          crs = GeoImportUtil.getDefaultCRS();
183                  this.style = style;                                  }
184                            }
185          }                  }
186                    return crs;
187          public void setTitle(Translation title) {          }
188                  this.title = title;  
189            public Translation getDesc() {
190          }                  return desc;
191            }
192          public void uncache() {  
193          }          public Envelope getEnvelope() {
194                    try {
195          /**                          return fs.getBounds();
196           *                  } catch (IOException e) {
197           */                          e.printStackTrace();
198          public Map<Integer, AttributeMetaData> getAttributeMetaDataMap() {                          return null;
199                  if (map == null) {                  }
200            }
201                          map = new HashMap<Integer, AttributeMetaData>();  
202            public FeatureSource<SimpleFeatureType, SimpleFeature> getGeoObject() {
203                          // Leaving out the first one, it will be the_geom                  return fs;
204                          for (int i = 1; i < fs.getSchema().getAttributeCount(); i++) {          }
205                                  AttributeType att = fs.getSchema().getAttributeType(i);  
206            public String getId() {
207                                  AttributeMetaData attMetaData = new AttributeMetaData(i, att                  return id;
208                                                  .getLocalName());          }
209                                  map.put(i, attMetaData);  
210                          }          public ImageIcon getImageIcon() {
211                  }                  return null;
212                  return map;          }
213          }  
214            public URL getInfoURL() {
215          /**                  return null;
216           * @return The {@link File} where the SLD was loaded from or          }
217           *         <code>null</code> if there didn't exist a {@link File}. (It could  
218           *         be a WFS or a PostGIS          public Translation getKeywords() {
219           *                  return null;
220           * @author <a href="mailto:[email protected]">Stefan Alfons          }
221           *         Kr&uuml;ger</a>  
222           */          public Style getStyle() {
223          public File getSldFile() {                  return style;
224                  return sldFile;          }
225          }  
226            public Translation getTitle() {
227          public void setSldFile(File sldFile) {                  return title;
228                  this.sldFile = sldFile;          }
229          }  
230            public boolean isDisposed() {
231  }                  return false;
232            }
233    
234            /**
235             * If true, this layer will not be shown in the legend. Default = false
236             */
237            /**
238             *
239             * Killed by SK: 6. April 09: Ein Layer soll nicht generell auf
240             * verstecken/nicht verstecken gestellt werden können. Das sind
241             * Eigenschaften der Karte/MapContext, ebenso wie die Reihenfolge der Layer.
242             * Im Atlas verwaltet deshalb nun die Klasse skrueger.atlas.Map welche Layer
243             * nicht in der Legende auftauchen sollen. Meines Wissens hat keiner bisher
244             * die Funktion genutzt.
245             *
246             * // public boolean isHideInLegend() { // return false; // }
247             */
248    
249            public void setDesc(Translation dec) {
250                    this.desc = dec;
251            }
252    
253            public void setImageIcon(ImageIcon icon) {
254            }
255    
256            public void setKeywords(Translation keywords) {
257            }
258    
259            public void setStyle(Style style) {
260                    this.style = style;
261    
262            }
263    
264            public void setTitle(Translation title) {
265                    this.title = title;
266    
267            }
268    
269            public void uncache() {
270            }
271    
272            /**
273             *
274             */
275            @Override
276            public AttributeMetadataMap<AttributeMetadataImpl> getAttributeMetaDataMap() {
277                    if (attMap == null) {
278                            attMap = StyledLayerUtil
279                                            .createDefaultAttributeMetadataMap(getSchema());
280                    }
281                    return attMap;
282            }
283    
284            /**
285             * @return The {@link File} where the SLD was loaded from or
286             *         <code>null</code> if there didn't exist a {@link File}.
287             *
288             * @author <a href="mailto:[email protected]">Stefan Alfons Tzeggai</a>
289             */
290            public File getSldFile() {
291                    return sldFile;
292            }
293    
294            /**
295             * Associates this .sld with the {@link FeatureSource}, but does not
296             * automatically load the file. It must not even exist.
297             *
298             * @param sldFile
299             */
300            public void setSldFile(File sldFile) {
301                    this.sldFile = sldFile;
302            }
303    
304            /**
305             * Returns the features of the {@link FeatureSource}.
306             *
307             * @see {@link StyledFeaturesInterface}
308             */
309            @Override
310            public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatureCollection() {
311                    FeatureCollection<SimpleFeatureType, SimpleFeature> features;
312                    try {
313                            features = getGeoObject().getFeatures();
314                    } catch (IOException e) {
315                            throw new RuntimeException(
316                                            "Error getting the features of the  FeatureSource");
317                    }
318                    return features;
319            }
320    
321            /**
322             * Same as {@link #getGeoObject()} method, but complies to the
323             * {@link StyledFeaturesInterface}
324             *
325             * @see {@link StyledFeaturesInterface}
326             */
327            @Override
328            public FeatureSource<SimpleFeatureType, SimpleFeature> getFeatureSource() {
329                    return getGeoObject();
330            }
331    
332            @Override
333            public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatureCollectionFiltered() {
334                    // final FeatureCollection<SimpleFeatureType, SimpleFeature> fc =
335                    // getFeatureCollection();
336                    // if (filter == Filter.EXCLUDE)
337                    // return new EmptyFeatureCollection(fc.getSchema());
338                    // if (filter == Filter.INCLUDE)
339                    // return fc;
340                    // return fc.subCollection(filter);
341    
342                    try {
343                            if (filter != Filter.INCLUDE)
344                                    return getFeatureSource().getFeatures(filter);
345                            else
346                                    return getFeatureSource().getFeatures();
347                    } catch (IOException e) {
348                            throw new RuntimeException(e);
349                    }
350            }
351    
352            @Override
353            public Filter getFilter() {
354                    return filter;
355            }
356    
357            @Override
358            public void setFilter(Filter filter) {
359                    this.filter = filter;
360            }
361    
362            @Override
363            public SimpleFeatureType getSchema() {
364                    return getGeoObject().getSchema();
365            }
366    
367            /**
368             * Tries to load a style from the file denoted in {@link #getSldFile()}. If
369             * the file doesn't exits, return <code>null</code>;
370             *
371             * @return <code>true</code> is style was loaded
372             */
373            public boolean loadStyle() {
374                    if (getSldFile() == null)
375                            return false;
376    
377                    try {
378                            Style[] loadSLD = StylingUtil.loadSLD(getSldFile());
379                            setStyle(loadSLD[0]);
380                            return true;
381                    } catch (Exception e) {
382                            return false;
383                    }
384    
385            }
386    
387            public void setTitle(String title) {
388                    setTitle(new Translation(title));
389            }
390    
391            public void setDesc(String desc) {
392                    setDesc(new Translation(desc));
393            }
394    
395            public void setCRS(CoordinateReferenceSystem crs2) {
396                    crs = crs2;
397            }
398    
399            @Override
400            public ReferencedEnvelope getReferencedEnvelope() {
401                    return new ReferencedEnvelope(getEnvelope(), getCrs());
402            }
403    
404    }
Legend:
Removed from v.169  
changed lines
  Added in v.1228
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26