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