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

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

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

revision 403 by alfonx, Mon Sep 14 13:29:42 2009 UTC revision 405 by alfonx, Mon Sep 14 15:43:28 2009 UTC
# Line 37  import java.awt.Rectangle; Line 37  import java.awt.Rectangle;
37  import java.awt.geom.AffineTransform;  import java.awt.geom.AffineTransform;
38  import java.awt.image.BufferedImage;  import java.awt.image.BufferedImage;
39  import java.awt.image.ColorModel;  import java.awt.image.ColorModel;
40    import java.awt.image.ComponentColorModel;
41    import java.awt.image.DataBuffer;
42  import java.io.File;  import java.io.File;
43  import java.io.FileNotFoundException;  import java.io.FileNotFoundException;
44  import java.io.FileWriter;  import java.io.FileWriter;
 import java.io.IOException;  
45  import java.net.URL;  import java.net.URL;
46  import java.text.DecimalFormat;  import java.text.DecimalFormat;
47  import java.util.HashMap;  import java.util.HashMap;
# Line 60  import org.geotools.coverage.grid.Genera Line 61  import org.geotools.coverage.grid.Genera
61  import org.geotools.coverage.grid.GridCoverage2D;  import org.geotools.coverage.grid.GridCoverage2D;
62  import org.geotools.coverage.grid.GridGeometry2D;  import org.geotools.coverage.grid.GridGeometry2D;
63  import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;  import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;
64    import org.geotools.coverage.grid.io.AbstractGridFormat;
65  import org.geotools.feature.FeatureCollection;  import org.geotools.feature.FeatureCollection;
66  import org.geotools.gce.imagepyramid.ImagePyramidReader;  import org.geotools.gce.imagepyramid.ImagePyramidReader;
67  import org.geotools.geometry.jts.ReferencedEnvelope;  import org.geotools.geometry.jts.ReferencedEnvelope;
68  import org.geotools.map.DefaultMapLayer;  import org.geotools.map.DefaultMapLayer;
69  import org.geotools.map.MapLayer;  import org.geotools.map.MapLayer;
70    import org.geotools.parameter.Parameter;
71  import org.geotools.renderer.lite.gridcoverage2d.GridCoverageRenderer;  import org.geotools.renderer.lite.gridcoverage2d.GridCoverageRenderer;
72  import org.geotools.styling.ColorMap;  import org.geotools.styling.ColorMap;
73  import org.geotools.styling.ColorMapEntry;  import org.geotools.styling.ColorMapEntry;
# Line 1004  public class StyledLayerUtil { Line 1007  public class StyledLayerUtil {
1007          /**          /**
1008           * Creates a           * Creates a
1009           *           *
1010           * @param styledGrid           * @param styledRaster
1011           * @param iconHeight           * @param iconHeight
1012           * @param iconWidth           * @param iconWidth
1013           * @return           * @return
1014           */           */
1015          public static Box createLegendPanel(StyledRasterInterface<?> styledGrid,          public static Box createLegendPanel(StyledRasterInterface<?> styledRaster,
1016                          int iconWidth, int iconHeight) {                          int iconWidth, int iconHeight) {
1017    
1018                  /**                  /**
1019                   * Determine whether a Style is responsible for the coloring                   * Determine whether a Style is responsible for the coloring
1020                   */                   */
                 Object geoObject = styledGrid.getGeoObject();  
1021                  ColorModel colorModel = null;                  ColorModel colorModel = null;
1022                  if (geoObject instanceof GridCoverage2D) {                  if (!isStyleable(styledRaster)
1023                          GridCoverage2D cov = (GridCoverage2D) geoObject;                                  || (isStyleable(styledRaster) && styledRaster.getStyle() != null)) {
1024                          colorModel = cov.getRenderedImage().getColorModel();                          colorModel = getColorModel(styledRaster);
                 } else if (geoObject instanceof ImagePyramidReader) {  
   
                         org.geotools.parameter.Parameter readGG = new org.geotools.parameter.Parameter(  
                                         org.geotools.coverage.grid.io.AbstractGridFormat.READ_GRIDGEOMETRY2D);  
   
                         ReferencedEnvelope mapExtend = new org.geotools.geometry.jts.ReferencedEnvelope(  
                                         styledGrid.getEnvelope(), styledGrid.getCrs());  
   
                         readGG.setValue(new GridGeometry2D(new GeneralGridEnvelope(  
                                         new Rectangle(0, 0, 10, 10)), mapExtend));  
   
                         final AbstractGridCoverage2DReader aReader = (AbstractGridCoverage2DReader) geoObject;  
                         try {  
                                 GridCoverage2D cov = (GridCoverage2D) aReader  
                                                 .read(new GeneralParameterValue[] { readGG });  
                                 colorModel = cov.getRenderedImage().getColorModel();  
                         } catch (IllegalArgumentException e) {  
                                 e.printStackTrace();  
                         } catch (IOException e) {  
                                 e.printStackTrace();  
                         }  
1025                  }                  }
1026    
1027                  RasterLegendData rasterLegendData = styledGrid.getLegendMetaData();                  RasterLegendData rasterLegendData = styledRaster.getLegendMetaData();
1028                  List<Double> legendRasterValues = rasterLegendData.getSortedKeys();                  List<Double> legendRasterValues = rasterLegendData.getSortedKeys();
1029                  Map<Double, GridCoverage2D> sampleRasters = rasterLegendData                  Map<Double, GridCoverage2D> sampleRasters = rasterLegendData
1030                                  .createSampleRasters();                                  .createSampleRasters();
# Line 1106  public class StyledLayerUtil { Line 1087  public class StyledLayerUtil {
1087                                          ICON_SIZE.height, BufferedImage.TYPE_INT_ARGB);                                          ICON_SIZE.height, BufferedImage.TYPE_INT_ARGB);
1088                          Graphics2D graphics = buffImage.createGraphics();                          Graphics2D graphics = buffImage.createGraphics();
1089    
1090                          if (colorModel != null)                          if (colorModel != null) {
1091    
1092                                  try {                                  try {
1093                                          final int rgb = colorModel.getRGB(rValue.intValue());                                          Object inData = null;
1094                                          final Color color = new Color(rgb);                                          switch (colorModel.getTransferType()) {
1095                                            case DataBuffer.TYPE_BYTE:
1096                                                    inData = new byte[] { rValue.byteValue() };
1097                                                    break;
1098                                            case DataBuffer.TYPE_USHORT:
1099                                                    inData = new short[] { rValue.shortValue() };
1100                                                    break;
1101                                            case DataBuffer.TYPE_INT:
1102                                                    inData = new int[] { rValue.intValue() };
1103                                                    break;
1104                                            case DataBuffer.TYPE_SHORT:
1105                                                    inData = new short[] { rValue.shortValue() };
1106                                                    break;
1107                                            case DataBuffer.TYPE_FLOAT:
1108                                                    inData = new float[] { rValue.floatValue() };
1109                                                    break;
1110                                            case DataBuffer.TYPE_DOUBLE:
1111                                                    inData = new double[] { rValue.doubleValue() };
1112                                                    break;
1113                                            default:
1114                                                    inData = rValue.intValue();
1115                                            }
1116                                            final Color color = new Color(colorModel.getRGB(inData));
1117                                          graphics.setBackground(color);                                          graphics.setBackground(color);
1118                                          graphics.setColor(color);                                          graphics.setColor(color);
1119                                          graphics.fillRect(0, 0, ICON_SIZE.width, ICON_SIZE.height);                                          graphics.fillRect(0, 0, ICON_SIZE.width, ICON_SIZE.height);
1120                                  } catch (Exception e) {                                  } catch (Exception e) {
1121                                          LOGGER.debug("Dann nehmen wir den GridCoverageRenderer", e);                                          LOGGER.debug("Dann nehmen wir halt den GridCoverageRenderer", e);
1122                                            colorModel = null;
1123                                    }
1124                            }
1125    
1126                                          /**                          if (colorModel == null) {
                                          * The coverage contains only one value of value rValue  
                                          */  
                                         GridCoverage2D sampleCov = sampleRasters.get(rValue);  
                                         GridCoverageRenderer renderer;  
                                         try {  
                                                 renderer = new GridCoverageRenderer(sampleCov  
                                                                 .getCoordinateReferenceSystem(), JTSUtil  
                                                                 .createEnvelope(sampleCov.getEnvelope()),  
                                                                 new Rectangle(iconWidth, iconHeight),  
                                                                 (AffineTransform) null);  
                                         } catch (Exception e1) {  
                                                 throw new RuntimeException(  
                                                                 "Creating the GridCoverageRenderer:", e1);  
                                         }  
1127    
1128                                          /**                                  /**
1129                                           * Iterate over all FeatureTypeStyles.                                   * The coverage contains only one value of value rValue
1130                                           */                                   */
1131                                          // for (FeatureTypeStyle ftStyle : styledGrid.getStyle()                                  GridCoverage2D sampleCov = sampleRasters.get(rValue);
1132                                          // .featureTypeStyles()) {                                  GridCoverageRenderer renderer;
1133                                          // One child-node for every rule                                  try {
1134                                          // List<Rule> rules = ftStyle.rules();                                          renderer = new GridCoverageRenderer(sampleCov
1135                                          // for (Rule rule : rules) {                                                          .getCoordinateReferenceSystem(), JTSUtil
1136                                          final Style style = styledGrid.getStyle();                                                          .createEnvelope(sampleCov.getEnvelope()),
1137                                          List<RasterSymbolizer> rSymbols = StylingUtil                                                          new Rectangle(iconWidth, iconHeight),
1138                                                          .getRasterSymbolizers(style);                                                          (AffineTransform) null);
1139                                    } catch (Exception e1) {
1140                                          for (RasterSymbolizer symbolizer : rSymbols) {                                          throw new RuntimeException(
1141                                                  // LOGGER.debug("Creating a new Legend Image for RUle                                                          "Creating the GridCoverageRenderer:", e1);
1142                                                  // name =                                  }
1143                                                  // "+rule.getName());  
1144                                                  try {                                  /**
1145                                                          renderer.paint(graphics, sampleCov, symbolizer);                                   * Iterate over all FeatureTypeStyles.
1146                                                  } catch (Exception ee) {                                   */
1147                                                          LOGGER.error("Unable to paint " + symbolizer                                  // for (FeatureTypeStyle ftStyle : styledGrid.getStyle()
1148                                                                          + " into the legend image", ee);                                  // .featureTypeStyles()) {
1149                                                  }                                  // One child-node for every rule
1150                                                  // }                                  // List<Rule> rules = ftStyle.rules();
1151                                                  // }                                  // for (Rule rule : rules) {
1152                                    final Style style = styledRaster.getStyle();
1153                                    List<RasterSymbolizer> rSymbols = StylingUtil
1154                                                    .getRasterSymbolizers(style);
1155    
1156                                    for (RasterSymbolizer symbolizer : rSymbols) {
1157                                            // LOGGER.debug("Creating a new Legend Image for RUle
1158                                            // name =
1159                                            // "+rule.getName());
1160                                            try {
1161                                                    renderer.paint(graphics, sampleCov, symbolizer);
1162                                            } catch (Exception ee) {
1163                                                    LOGGER.error("Unable to paint " + symbolizer
1164                                                                    + " into the legend image", ee);
1165                                          }                                          }
1166                                            // }
1167                                            // }
1168                                  }                                  }
1169                            }
1170    
1171                          ImageIcon legendIcon = new ImageIcon(buffImage);                          ImageIcon legendIcon = new ImageIcon(buffImage);
1172    
# Line 1184  public class StyledLayerUtil { Line 1193  public class StyledLayerUtil {
1193                  return box;                  return box;
1194          }          }
1195    
1196            /**
1197             * Extracts the {@link ColorModel} of any {@link StyledRasterInterface}. May
1198             * return <code>null</code> if the geoobject can not be accessed.
1199             */
1200            public static ColorModel getColorModel(StyledRasterInterface<?> styledGrid) {
1201                    ColorModel colorModel = null;
1202                    try {
1203                            Object geoObject = styledGrid.getGeoObject();
1204                            if (geoObject instanceof GridCoverage2D) {
1205                                    GridCoverage2D cov = (GridCoverage2D) geoObject;
1206                                    colorModel = cov.getRenderedImage().getColorModel();
1207                            } else if (geoObject instanceof ImagePyramidReader) {
1208    
1209                                    Parameter readGG = new Parameter(
1210                                                    AbstractGridFormat.READ_GRIDGEOMETRY2D);
1211    
1212                                    ReferencedEnvelope mapExtend = new org.geotools.geometry.jts.ReferencedEnvelope(
1213                                                    styledGrid.getEnvelope(), styledGrid.getCrs());
1214    
1215                                    readGG.setValue(new GridGeometry2D(new GeneralGridEnvelope(
1216                                                    new Rectangle(0, 0, 10, 10)), mapExtend));
1217    
1218                                    final AbstractGridCoverage2DReader aReader = (AbstractGridCoverage2DReader) geoObject;
1219                                    GridCoverage2D cov = (GridCoverage2D) aReader
1220                                                    .read(new GeneralParameterValue[] { readGG });
1221                                    colorModel = cov.getRenderedImage().getColorModel();
1222                            }
1223                    } catch (Exception e) {
1224                            LOGGER.error("Error reading the colormodel from " + styledGrid);
1225                            return null;
1226                    }
1227                    return colorModel;
1228            }
1229    
1230            /**
1231             * @return <code>true</code> if a {@link RasterSymbolizer} can be applied
1232             *         and will have an effect. Some rasters (e.g. GeoTIFF) can come
1233             *         with their own {@link ColorModel} and will ignore any
1234             *         {@link RasterSymbolizer} = SLD.
1235             */
1236            public static boolean isStyleable(StyledRasterInterface<?> styledRaster) {
1237                    ColorModel colorModel = getColorModel(styledRaster);
1238    
1239                    LOGGER.info("The colormodel of " + styledRaster.getTitle() + " is "
1240                                    + colorModel.getClass().getSimpleName());
1241    
1242                    if (colorModel == null)
1243                            return true;
1244                    if (colorModel instanceof ComponentColorModel)
1245                            return true;
1246                    return false;
1247            }
1248  }  }
Legend:
Removed from v.403  
changed lines
  Added in v.405
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26