/[schmitzm]/branches/2.0-GP14/src/skrueger/geotools/StyledFS.java
ViewVC logotype

Diff of /branches/2.0-GP14/src/skrueger/geotools/StyledFS.java

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

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