// **********************************************************************// // <copyright>// //  BBN Technologies//  10 Moulton Street//  Cambridge, MA 02138//  (617) 873-8000// //  Copyright (C) BBNT Solutions LLC. All rights reserved.// // </copyright>// **********************************************************************// // $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/omGraphics/grid/SimpleColorGenerator.java,v $// $RCSfile: SimpleColorGenerator.java,v $// $Revision: 1.3.2.2 $// $Date: 2005/12/22 18:42:48 $// $Author: dietrick $// // **********************************************************************package com.bbn.openmap.omGraphics.grid;import com.bbn.openmap.omGraphics.OMGraphic;import com.bbn.openmap.omGraphics.OMGrid;import com.bbn.openmap.omGraphics.OMRaster;import com.bbn.openmap.omGraphics.SinkGraphic;import com.bbn.openmap.proj.Projection;import com.bbn.openmap.util.Debug;/** * The SimpleColorGenerator is an OMGridGenerator that creates an OMRaster out * of OMGrid data. The OMgrid data is assumed to be color ARGB integer values. * Each pixel is colored according to the closest grid data point value. */public class SimpleColorGenerator implements OMGridGenerator {    /**     * Going to return an OMRaster, sized to the current projection, and colored     * according to the colortable. The grid values are indexes into the     * colortable. The grid should already be generated when it gets here -     * meaning that the bounds and parameters of the grid, as they apply to the     * projection, are figured out.     *      * @param grid the grid to create a raster for.     * @param proj description of the map.     */    public OMGraphic generate(OMGrid grid, Projection proj) {        Debug.message("grid",                "SimpleColorGenerator: generating OMRaster from grid");        if (grid.height <= 0 || grid.width <= 0) {            Debug.message("grid",                    "SimpleColorGenerator: grid height/width ZERO!");            return SinkGraphic.getSharedInstance();        }        OMRaster raster = new OMRaster(grid.point1.x, grid.point1.y, grid.width, grid.height, new int[grid.width                * grid.height]);        int rows = grid.getRows();        int columns = grid.getColumns();        RasterHelper rasterHelper = getRasterHelper(grid.getData());        boolean major = grid.getMajor();        /** lat and lon_intervals are grid point/pixel.. */        double y_interval = (double) rows / (double) grid.height;        double x_interval = (double) columns / (double) grid.width;        Debug.message("grid", "SimpleColorGenerator: y_point_interval = "                + y_interval + ", x_point_interval = " + x_interval);        /**         * Right now, if the rendertype of the grid is RENDERTYPE_LATLON, we         * limit sensible rendering to the CADRG/LLXY projections. No warping         * done.         */        int post_x, post_y, value;        /** Do this pixel by pixel. */        for (int x = 0; x < grid.width; x++) {            for (int y = 0; y < grid.height; y++) {                post_x = (int) Math.round(x_interval * (double) x);                if (grid.getRenderType() == OMGraphic.RENDERTYPE_LATLON) {                    post_y = (int) Math.round(y_interval                            * (grid.height - 1 - (double) y));                } else {                    post_y = (int) Math.round(y_interval * (double) y);                }                if (major == OMGrid.COLUMN_MAJOR) {                    if (post_x >= columns)                        post_x = columns - 1;                    if (post_y >= rows)                        post_y = rows - 1;                    value = calibratePointValue(rasterHelper.get(post_x, post_y));                } else {                    if (post_y >= columns)                        post_y = columns - 1;                    if (post_x >= rows)                        post_x = rows - 1;                    value = calibratePointValue(rasterHelper.get(post_y, post_x));                }                raster.setPixel(x, y, value);            }        }        raster.generate(proj);        return raster;    }    /**     * Takes the value assigned to a pixel, as determined by it's location in     * the grid, and gives a color to paint the pixel. In this case, the grid     * point value IS the color value.     *      * @param source a grid point value assigned to the raster pixel.     * @return the ARGB to color the pixel.     */    public int calibratePointValue(int source) {        return source;    }    /**     * We at least need one generate for XY and OFFSET grids. We will need a     * generate every time the projection changes for LATLON rendertype grids.     * So return true for everything.     */    public boolean needGenerateToRender() {        return true;    }    /**     * This method creates a set of greyscale colors. It isn't used in this     * class (SimpleColorGenerator), but it probably will be used in extended     * classes.     *      * @param num_colors the number of greys needed.     * @param opaqueness how clear the color should be (0-255, where 0 is     *        clear).     * @return an array of color ARGB integers.     */    public int[] createGreyscaleColors(int num_colors, int opaqueness) {        int[] tempColors = new int[num_colors];        if (num_colors == 0) {            num_colors = 216;        }        int grey_interval = 256 / num_colors;        for (int i = 0; i < num_colors; i++) {            if (i == 0) {                tempColors[i] = ((opaqueness & 0xFF) << 24)                        | ((191 & 0xFF) << 16) | ((239 & 0xFF) << 8)                        | ((255 & 0xFF));            }            else {                int color = (i * grey_interval) + (grey_interval / 2);                tempColors[i] = ((opaqueness & 0xFF) << 24)                        | ((color & 0xFF) << 16) | ((color & 0xFF) << 8)                        | ((color & 0xFF));            }        }        return tempColors;    }    protected RasterHelper getRasterHelper(GridData gd) {        if (gd instanceof GridData.Short) {            return new ShortRasterHelper(((GridData.Short) gd).getData());        } else if (gd instanceof GridData.Int) {            return new IntRasterHelper(((GridData.Int) gd).getData());        } else if (gd instanceof GridData.Float) {            return new FloatRasterHelper(((GridData.Float) gd).getData());        } else if (gd instanceof GridData.Byte) {            return new ByteRasterHelper(((GridData.Byte) gd).getData());        } else if (gd instanceof GridData.Char) {            return new CharRasterHelper(((GridData.Char) gd).getData());        }        return new DoubleRasterHelper(((GridData.Double) gd).getData());    }    protected interface RasterHelper {        public int get(int x, int y);    }    protected class IntRasterHelper implements RasterHelper {        int[][] data;        public IntRasterHelper(int[][] intData) {            data = intData;        }        public int get(int x, int y) {            return data[x][y];        }    }    protected class ShortRasterHelper implements RasterHelper {        short[][] data;        public ShortRasterHelper(short[][] intData) {            data = intData;        }        public int get(int x, int y) {            return data[x][y];        }    }    protected class ByteRasterHelper implements RasterHelper {        byte[][] data;        public ByteRasterHelper(byte[][] intData) {            data = intData;        }        public int get(int x, int y) {            return data[x][y];        }    }    protected class FloatRasterHelper implements RasterHelper {        float[][] data;        public FloatRasterHelper(float[][] intData) {            data = intData;        }        public int get(int x, int y) {            return (int) data[x][y];        }    }    protected class DoubleRasterHelper implements RasterHelper {        double[][] data;        public DoubleRasterHelper(double[][] intData) {            data = intData;        }        public int get(int x, int y) {            return (int) data[x][y];        }    }    protected class CharRasterHelper implements RasterHelper {        char[][] data;        public CharRasterHelper(char[][] intData) {            data = intData;        }        public int get(int x, int y) {            return data[x][y];        }    }}