/[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 2 by mojays, Tue Feb 24 22:43:52 2009 UTC revision 863 by alfonx, Sun May 23 13:42:13 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.FileNotFoundException;
34          private static final Logger LOGGER = Logger.getLogger(StyledFS.class);  import java.io.IOException;
35    import java.net.URL;
36          private final FeatureSource fs;  import java.util.Date;
37    import java.util.Random;
38          /**  
39           * A unique ID which identifies the Layer in the Atlas. It's more important  import javax.swing.ImageIcon;
40           * than it should be ;-)  import javax.swing.JPanel;
41           */  
42          private String id;  import org.apache.log4j.Logger;
43    import org.geotools.data.FeatureSource;
44          private Style style;  import org.geotools.feature.FeatureCollection;
45    import org.geotools.feature.NameImpl;
46          private Translation title;  import org.geotools.styling.Style;
47    import org.opengis.feature.simple.SimpleFeature;
48          private Translation desc;  import org.opengis.feature.simple.SimpleFeatureType;
49    import org.opengis.feature.type.AttributeDescriptor;
50          private File sldFile;  import org.opengis.filter.Filter;
51    import org.opengis.referencing.crs.CoordinateReferenceSystem;
52          private HashMap<Integer, AttributeMetaData> map;  
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.AttributeMetadataInterface;
57           *  import skrueger.i8n.Translation;
58           * @param fs  
59           *            {@link FeatureSource} that is beeing styled.  import com.vividsolutions.jts.geom.Envelope;
60           *  
61           * @param sldFile  /**
62           *            may be <code>null</code>. Otherwise the SLD {@link File} to   * This class enables a non Atlas context to use the Atlas LayerPanel
63           *            import and associate with this {@link StyledFS}   * {@link JPanel} as a {@link MapContextManagerInterface}
64           */   *
65          public StyledFS(FeatureSource fs, File sldFile) {   * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>
66     *
67                  super();   *         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                          }           */
81                  }          private String id;
82    
83                  title = new Translation();          private Style style;
84                  title.fromOneLine(sldFile.getName());  
85            private Translation title;
86                  desc = new Translation();  
87                  desc.fromOneLine(sldFile.getAbsolutePath());          private Translation desc;
88          }  
89            private File sldFile;
90          public void dispose() {  
91          }          /** A map of simple attribute names to their meta-data **/
92            private AttributeMetadataMap<AttributeMetadataImpl> map;
93          /**  
94           * Returnes human readable {@link String} of the CRS natively used by this          private Filter filter = Filter.INCLUDE;
95           * {@link DpLayer}  
96           *          /**
97           * If crs == null, it will call {@link #getGeoObject()}           * This class enables a non Atlas context to use the Atlas LayerPanel
98           *           * {@link JPanel} as a {@link MapContextManagerInterface}
99           */           *
100          public String getCRSString() {           * @param fs
101                  if (getCrs() == null)           *            {@link FeatureSource} that is beeing styled.
102                          return "CRS?";           *
103             * @param sldFile
104                  return getCrs().getName().getCode();           *            may be <code>null</code>. Otherwise the SLD {@link File} to
105          }           *            import and associate with this {@link StyledFS}
106             */
107          public CoordinateReferenceSystem getCrs() {          public StyledFS(FeatureSource<SimpleFeatureType, SimpleFeature> fs,
108                  return fs.getSchema().getDefaultGeometry().getCoordinateSystem();                          File sldFile) {
109          }  
110                    this.fs = fs;
111          public Translation getDesc() {  
112                  return desc;                  id = StyledFS.class.getSimpleName()
113          }                                  + new Random(new Date().getTime()).nextInt(10000000);
114    
115          public Envelope getEnvelope() {                  this.sldFile = sldFile;
116                  try {  
117                          return fs.getBounds();                  // datei existiert, dann lesen
118                  } catch (IOException e) {                  if (sldFile != null && sldFile.exists()) {
119                          e.printStackTrace();                          try {
120                          return null;                                  style = StylingUtil.loadSLD(sldFile)[0];
121                  }                          } catch (Exception e) {
122          }                                  LOGGER.warn("Reading SLD failed: " + sldFile, e);
123                                    style = null;
124          public FeatureSource getGeoObject() throws Exception {                          }
125                  return fs;                  }
126          }  
127                    title = new Translation();
128          public String getId() {                  desc = new Translation();
129                  return id;  
130          }                  if (sldFile != null) {
131                            title.fromOneLine(sldFile.getName());
132          public ImageIcon getImageIcon() {                          desc.fromOneLine(sldFile.getAbsolutePath());
133                  return null;                  }
134          }  
135            }
136          public URL getInfoURL() {  
137                  return null;          public StyledFS(FeatureSource<SimpleFeatureType, SimpleFeature> fs) {
138          }                  this(fs, null);
139            }
140          public Translation getKeywords() {  
141                  return null;          public void dispose() {
142          }          }
143    
144          public Style getStyle() {          /**
145                  return style;           * Returns human readable {@link String} of the CRS natively used by this
146          }           * {@link DpLayer}
147             *
148          public Translation getTitle() {           * If CRS == null, it will call {@link #getGeoObject()}
149                  return title;           *
150          }           */
151            public String getCRSString() {
152          public boolean isDisposed() {                  if (getCrs() == null)
153                  return false;                          return "CRS?";
154          }  
155                    return getCrs().getName().getCode();
156          public boolean isHideInLegend() {          }
157                  return false;  
158          }          public CoordinateReferenceSystem getCrs() {
159                    if (crs == null) {
160          public void setDesc(Translation dec) {                          crs = fs.getSchema().getCoordinateReferenceSystem();
161                  this.desc = dec;                          if (fs.getSchema().getCoordinateReferenceSystem() == null) {
162          }                                  LOGGER.warn("Could not determine the CRS of " + getTitle()
163                                                    + ". Using default " + GeoImportUtil.getDefaultCRS());
164          public void setImageIcon(ImageIcon icon) {                                  crs = GeoImportUtil.getDefaultCRS();
165                  // TODO Auto-generated method stub                          }
166                    }
167          }                  return crs;
168            }
169          public void setKeywords(Translation keywords) {  
170          }          public Translation getDesc() {
171                    return desc;
172          public void setStyle(Style style) {          }
173                  this.style = style;  
174            public Envelope getEnvelope() {
175          }                  try {
176                            return fs.getBounds();
177          public void setTitle(Translation title) {                  } catch (IOException e) {
178                  this.title = title;                          e.printStackTrace();
179                            return null;
180          }                  }
181            }
182          public void uncache() {  
183          }          public FeatureSource<SimpleFeatureType, SimpleFeature> getGeoObject() {
184                    return fs;
185          public Map<Integer, AttributeMetaData> getAttributeMetaDataMap() {          }
186                  if (map == null) {  
187                          map = new HashMap<Integer, AttributeMetaData>();          public String getId() {
188                                            return id;
189                          // Leaving out the first one, it will be the_geom          }
190                          for (int i = 1; i < fs.getSchema().getAttributeCount(); i++) {  
191                                  AttributeType att = fs.getSchema().getAttributeType(i);          public ImageIcon getImageIcon() {
192                                                    return null;
193                                  AttributeMetaData attMetaData = new AttributeMetaData(i, att.getLocalName());          }
194                                  map.put(i, attMetaData);  
195                          }          public URL getInfoURL() {
196                  }                  return null;
197                  return map;          }
198          }  
199            public Translation getKeywords() {
200          /**                  return null;
201           * @return The {@link File} where the SLD was loaded from or          }
202           *         <code>null</code> if there didn't exist a {@link File}. (It  
203           *         could be a WFS or a PostGIS          public Style getStyle() {
204           *                  return style;
205           * @author <a href="mailto:[email protected]">Stefan Alfons Kr&uuml;ger</a>          }
206           */  
207          public File getSldFile() {          public Translation getTitle() {
208                  return sldFile;                  return title;
209          }          }
210    
211          public void setSldFile(File sldFile) {          public boolean isDisposed() {
212                  this.sldFile = sldFile;                  return false;
213          }          }
214    
215  }          /**
216             * If true, this layer will not be shown in the legend. Default = false
217             */
218            /**
219             *
220             * Killed by SK: 6. April 09: Ein Layer soll nicht generell auf
221             * verstecken/nicht verstecken gestellt werden können. Das sind
222             * Eigenschaften der Karte/MapContext, ebenso wie die Reihenfolge der Layer.
223             * Im Atlas verwaltet deshalb nun die Klasse skrueger.atlas.Map welche Layer
224             * nicht in der Legende auftauchen sollen. Meines Wissens hat keiner bisher
225             * die Funktion genutzt.
226             *
227             * // public boolean isHideInLegend() { // return false; // }
228             */
229    
230            public void setDesc(Translation dec) {
231                    this.desc = dec;
232            }
233    
234            public void setImageIcon(ImageIcon icon) {
235            }
236    
237            public void setKeywords(Translation keywords) {
238            }
239    
240            public void setStyle(Style style) {
241                    this.style = style;
242    
243            }
244    
245            public void setTitle(Translation title) {
246                    this.title = title;
247    
248            }
249    
250            public void uncache() {
251            }
252    
253            /**
254             *
255             */
256            public AttributeMetadataMap<AttributeMetadataImpl> getAttributeMetaDataMap() {
257                    if (map == null) {
258    
259                            map = new AttributeMetadataImplMap();
260    
261                            // // Leaving out the first one, it will be the_geom
262                            // for (int i = 1; i < fs.getSchema().getAttributeCount(); i++) {
263                            // AttributeDescriptor attDesc = fs.getSchema().getDescriptor(i);
264                            //
265                            // AttributeMetadataImpl attMetaData = new AttributeMetadataImpl(
266                            // new NameImpl(attDesc
267                            // .getName().getNamespaceURI(), attDesc
268                            // .getName().getLocalPart()), map.getLanguages());
269                            // map.put(attDesc.getName(), attMetaData);
270                            // }
271    
272                            // Leaving out the first one, it will be the_geom
273                            for (int i = 1; i < fs.getSchema().getAttributeCount(); i++) {
274                                    AttributeDescriptor attDesc = fs.getSchema().getDescriptor(i);
275    
276                                    // TODO AttributeMetadataAS would be nicer, which would not work
277                                    // with Translations ;-)
278                                    AttributeMetadataImpl attMetaData = new AttributeMetadataImpl(
279                                                    new NameImpl(attDesc.getName().getNamespaceURI(),
280                                                                    attDesc.getName().getLocalPart()), map
281                                                                    .getLanguages());
282                                    if (String.class.isAssignableFrom(attDesc.getType()
283                                                    .getBinding())) {
284                                            // For Strings we add the "" as NODATA values
285                                            attMetaData.addNodataValue("");
286                                    }
287                                    map.put(attDesc.getName(), attMetaData);
288                            }
289                    }
290                    return map;
291            }
292    
293            /**
294             * @return The {@link File} where the SLD was loaded from or
295             *         <code>null</code> if there didn't exist a {@link File}.
296             *
297             * @author <a href="mailto:[email protected]">Stefan Alfons
298             *         Kr&uuml;ger</a>
299             */
300            public File getSldFile() {
301                    return sldFile;
302            }
303    
304            public void setSldFile(File sldFile) {
305                    this.sldFile = sldFile;
306            }
307    
308            /**
309             * Returns the features of the {@link FeatureSource}.
310             *
311             * @see {@link StyledFeaturesInterface}
312             */
313            @Override
314            public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatureCollection() {
315                    FeatureCollection<SimpleFeatureType, SimpleFeature> features;
316                    try {
317                            features = getGeoObject().getFeatures();
318                    } catch (IOException e) {
319                            throw new RuntimeException(
320                                            "Error getting the features of the  FeatureSource");
321                    }
322                    return features;
323            }
324    
325            /**
326             * Same as {@link #getGeoObject()} method, but complies to the
327             * {@link StyledFeaturesInterface}
328             *
329             * @see {@link StyledFeaturesInterface}
330             */
331            @Override
332            public FeatureSource<SimpleFeatureType, SimpleFeature> getFeatureSource() {
333                    return getGeoObject();
334            }
335    
336            @Override
337            public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatureCollectionFiltered() {
338                    // final FeatureCollection<SimpleFeatureType, SimpleFeature> fc =
339                    // getFeatureCollection();
340                    // if (filter == Filter.EXCLUDE)
341                    // return new EmptyFeatureCollection(fc.getSchema());
342                    // if (filter == Filter.INCLUDE)
343                    // return fc;
344                    // return fc.subCollection(filter);
345    
346                    try {
347                            return getFeatureSource().getFeatures(filter);
348                    } catch (IOException e) {
349                            throw new RuntimeException(e);
350                    }
351            }
352    
353            @Override
354            public Filter getFilter() {
355                    return filter;
356            }
357    
358            @Override
359            public void setFilter(Filter filter) {
360                    this.filter = filter;
361            }
362    
363            @Override
364            public SimpleFeatureType getSchema() {
365                    return getGeoObject().getSchema();
366            }
367    
368            /**
369             * Tries to load a style from the file denoted in {@link #getSldFile()}. If
370             * the file doesn't exits, return <code>null</code>;
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    }

Legend:
Removed from v.2  
changed lines
  Added in v.863

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26