| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *   +34 963862235

 *   gvsig@gva.es

 *   http://www.gvsig.gva.es

 *

 *    or

 *

 *   Prodevelop Integraci?n de Tecnolog?as SL

 *   Conde Salvatierra de ?lava , 34-10

 *   46004 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 *

 *    or

 *

 *   Instituto de Rob?tica

 *   Apartado de correos 2085

 *   46071 Valencia

 *   (Spain)

 *   

 *   +34 963 543 577

 *   jjordan@robotica.uv.es

 *   http://robotica.uv.es

 *   

 */

package es.prodevelop.gvsig.mobile.fmap.driver.raster.memory.wkformat;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.image.DataBuffer;

import java.io.File;

import java.io.IOException;

import org.apache.log4j.Logger;

import es.prodevelop.gvsig.mobile.fmap.driver.FMapDriverException;

import es.prodevelop.gvsig.mobile.fmap.driver.raster.GeorreferencedRasterDriver;

import es.prodevelop.gvsig.mobile.fmap.proj.IProjection;

import es.prodevelop.gvsig.mobile.fmap.util.ResourceReader;

import es.prodevelop.gvsig.mobile.fmap.util.Utils;

import es.prodevelop.gvsig.mobile.fmap.viewport.ViewPort;

/**

 * Raster driver for well known image formats (PNg, JPG, GIF). These images

 * have to be loaded completely in memory, so the size is limited to a few hundred

 * thousands pixels.

 * 

 * @see java.awt.geom.AffineTransform

 * 

 * @author jldominguez

 *

 */

public class WKFRasterDriver implements GeorreferencedRasterDriver {

        private static final int WKRASTER_MAX_PIXEL_COUNT = 500000;

        private static Logger logger = Logger.getLogger(WKFRasterDriver.class);

        private IProjection proj = null;

        private int trans = 0;

        private AffineTransform at = AffineTransform.getTranslateInstance(0, 0);

        private ViewPort viewPort;

        private Rectangle2D extent = null;

        private int imgWidth = 1;

        private int imgHeight = 1;

        private String path = "";

        private byte[] imageFileBytes = null;

        /**

         * Constructor.

         * 

         * @param vp current view port, used for geographic computations

         */

        public WKFRasterDriver(ViewPort vp) {

                viewPort = vp;

        }

        /**

         * Initializes  the driver. Simply sets the projection.

         * 

         * @param p the current projection

         */

        public void initialize(IProjection p) throws IOException {

                proj = p;

        }

        /**

         * @return the current projection

         */

        public IProjection getProjection() {

                return proj;

        }

        /**

         * Sets a new projection

         * 

         * @param p the new projection to be set.

         */

        public void setProjection(IProjection p) {

                proj = p;

        }

        /**

         * @return the full extent of the raster

         */

        public Rectangle2D getFullExtent() {

                return extent;

        }

        /**

         * @return whether this raster is georrefernced. Returns true.

         */

        public boolean isGeoreferenced() {

                return true;

        }

        /**

         * Sets a new affine transformation. 

         * @param t the new affine transform

         */

        public void setAffineTransform(AffineTransform t) {

                // at = t;

                logger.warn("Someone tried to set WKR raster driver AffineTransform (?)");

        }

        /**

         * @return the current affine transform

         */

        public AffineTransform getAffineTransform() {

                return at;

        }

        /**

         * @return whether the provided file object is acceptable as an input raster file.

         */

        public boolean fileAccepted(File fName) {

                String aux = fName.getAbsolutePath();

                int l = aux.length();

                aux = aux.substring(l - 4, l);

                if (aux.compareToIgnoreCase("jpeg") == 0) return true;

                aux = aux.substring(l - 3, l);

                if (aux.compareToIgnoreCase("jpg") == 0) return true;

                if (aux.compareToIgnoreCase("png") == 0) return true;

                if (aux.compareToIgnoreCase("gif") == 0) return true;

                return false;

        }

        private Image getImageFromBytes(byte[] bb) throws IOException {

                // Image resp = Toolkit.getDefaultToolkit().createImage(bb);

                Image resp = ResourceReader.getImage(bb);

                if (resp == null) throw new IOException("Did not read image (img = null)");

                if (resp.getWidth(null) == -1) throw new IOException("Did not read image (w/h = -1)");

                if ((resp.getWidth(null)  * resp.getHeight(null)) > WKRASTER_MAX_PIXEL_COUNT) {

                        throw new IOException("Image is too large (>" +

                                        Utils.getFormattedDouble(0.000001 * WKRASTER_MAX_PIXEL_COUNT, 2) +

                                        "Megapixels)");

                }

                return resp;

        }

        /**

         * Opens the specified file and expands it complete in memory. This is the biggest issue

         * with this type of image files (png, jpg, gif). Their size is very limited

         * because they cannot be accessed for a limited zone of interest.

         * 

         * @param f the raster file to be opened

         */

        public void open(File f) throws IOException {

                try {

                        imageFileBytes = Utils.readFileIntoByteArray(f);

                        logger.debug("byte[] file_bytes.length = " + imageFileBytes.length);

                        Image wholeImage = getImageFromBytes(imageFileBytes);

                        imgWidth = wholeImage.getWidth(null);

                        imgHeight = wholeImage.getHeight(null);

                        logger.debug("imgWidth = " + imgWidth);

                        logger.debug("imgHeight = " + imgHeight);

                        wholeImage = null;

                        System.gc();

                        path = f.getAbsolutePath();

                        int lastp = path.lastIndexOf(".");

                        String ext = path.substring(lastp + 1, path.length());

                        String[] valid = getWorldFileExtensions(ext);

                        at = Utils.readWldFile(f, valid);

                        extent = Utils.getExtent(at, imgWidth, imgHeight);

                } catch (IOException ex) {

                        logger.error("While opening WK raster file: " + ex.getMessage());

                        throw new IOException(ex.getMessage());

                }

        }

        /**

         * Initializes the driver. Right now it's an empty method.

         * 

         */

        public void initialize() throws IOException {

        }

        /**

         * Closes the driver. Right now it's an empty method.

         */

        public void close() throws IOException {

        }

        /**

         * @return the number of bands in this raster.

         */

        public int getNumBands() {

                return 3;

        }

        /**

         * @return the current transparency level of this image 

         */

        public int getTransparency() {

                return trans;

        }

        /**

         * Sets the transparency level of this image

         * @param t the new transparecncy level

         */

        public void setTransparency(int t) {

                trans = t;

        }

        /**

         * Draws the image. This method tries to behave in the less memory-consuming way.

         * 

         * If the view is larger than the image, the image is resampled down. If

         * the image is larger than the view, a new buffered image is created , then the image

         * is painted on it (clipping), then the buffered image is resampled up.

         * 

         * @param g the graphics object where the image has to be painted

         * @param viewPort the current viewport.

         * 

         */

        public void draw(Graphics2D g, ViewPort viewPort)

                        throws FMapDriverException {

                Rectangle2D vext = viewPort.getAdjustedExtent();

                if (! Utils.rectanglesItersect(vext, extent)) {

                        return;

                }

                int[] raster_transf = getRasterTansformation(

                                vext,

                                extent, viewPort.getImageWidth(), imgWidth, imgHeight);

                for (int i=0; i<raster_transf.length; i++) {

                        logger.debug("raster_transf[" + i + "] = " + raster_transf[i]); 

                }

                if (raster_transf == null) return;

                Image wholeImage = null;

                try {

                        wholeImage = getImageFromBytes(imageFileBytes);

                } catch (IOException e) {

                        throw new FMapDriverException(e.getMessage());

                }

                if (raster_transf.length == 8) {

                        // zoom in

                        logger.debug("DRAW WK RASTER: CASE 1: ZOOM IN:");

                        BufferedImage bim = Utils.createBufferedImage(raster_transf[2], raster_transf[3]);

                        if ((bim == null) || (bim.getWidth(null) != raster_transf[2])) {

                                throw new FMapDriverException("Could not instantiate buff image.");

                        }

                        bim.getGraphics().drawImage(wholeImage, -raster_transf[0], -raster_transf[1], null);

                        logger.debug("Scale up: " + (raster_transf[4]) + ", " + (raster_transf[5]));

                        try {

                                g.drawImage(

                                        bim.getScaledInstance(

                                                        raster_transf[4],

                                                        raster_transf[5],

                                                        Image.SCALE_FAST),

                                        raster_transf[6], raster_transf[7], null);

                        } catch (Throwable th) {

                                logger.error("While resampling image: " + th.getMessage());

                                bim = null;

                                throw new FMapDriverException(th.getMessage());

                        }

                        bim = null;

                } else {

                        Rectangle2D interse = new Rectangle2D.Double();

                        Rectangle2D.intersect(vext, extent, interse);

                        int bi_w = Math.round( (float) ((interse.getWidth() / extent.getWidth()) * imgWidth));

                        int bi_h = Math.round( (float) ((interse.getHeight() / extent.getHeight()) * imgHeight));

                        // decision:

                        // (whole raster resized down) vs. (zone of interest resized up)

                        int whole_raster_resized_down = raster_transf[2] * raster_transf[3];

                        int zone_of_interest_resized_up = bi_w * bi_h;

                        logger.debug("Decision: ");

                        logger.debug("whole_raster_resized_down:  = " + whole_raster_resized_down);

                        logger.debug("zone_of_interest_resized_up: = " + zone_of_interest_resized_up);

                        // raster_transf.length == 4

                        // downsample whole raster (to small size), then paint

                        if (whole_raster_resized_down < zone_of_interest_resized_up) {

                                logger.debug("DRAW WK RASTER: CASE 2: ZOOM OUT, RESAMPLE WHOLE TO SMALL IMAGE");

                                logger.debug("Resample whole to: " + raster_transf[2] + ", " + raster_transf[3]);

                                Image smallImage = wholeImage.getScaledInstance(

                                                raster_transf[2],

                                                raster_transf[3],

                                                Image.SCALE_FAST);

                                if ((smallImage == null) || (smallImage.getWidth(null) != raster_transf[2])) {

                                        throw new FMapDriverException("Could not resample image (down).");

                                }

                                logger.debug("Final drarw, offset: " + raster_transf[0] + ", " + raster_transf[1]);

                                g.drawImage(smallImage, raster_transf[0], raster_transf[1], null);

                        } else {

                                logger.debug("DRAW WK RASTER: CASE 3: ZOOM OUT, GET PIECE, RESAMPLE UP, DRAW");

                                // get raster piece, paint on it, resample up:

                                logger.debug("Piece of interest size: " + bi_w + ", " + bi_h);

                                BufferedImage bi = Utils.createBufferedImage(bi_w, bi_h);

                                int bim_offset_x =

                                        Math.round( (float) (((interse.getMinX() - extent.getMinX()) / extent.getWidth()) * imgWidth));

                                int bim_offset_y =

                                        Math.round( (float) (((extent.getMaxY() - interse.getMaxY()) / extent.getHeight()) * imgHeight));

                                logger.debug("Piece of interest offset from raster: " + bim_offset_x + ", " + bim_offset_y);

                                bi.getGraphics().drawImage(wholeImage, -bim_offset_x, -bim_offset_y, null);

                                // new bim size

                                bi_w =

                                        Math.round( (float) ((interse.getWidth() / vext.getWidth()) * viewPort.getImageWidth()));

                                bi_h =

                                        Math.round( (float) ((interse.getHeight() / vext.getHeight()) * viewPort.getImageHeight()));

                                logger.debug("Piece of interest resize to: " + bi_w + ", " + bi_h);

                                Image smallImage = bi.getScaledInstance(bi_w, bi_h, Image.SCALE_FAST);

                                // new bim offset to screen

                                bim_offset_x =

                                        Math.round( (float) (((interse.getMinX() - vext.getMinX()) / vext.getWidth()) * viewPort.getImageWidth()));

                                bim_offset_y =

                                        Math.round( (float) (((vext.getMaxY() - interse.getMaxY()) / vext.getHeight()) * viewPort.getImageHeight()));

                                logger.debug("Piece of interest offset from view: " + bim_offset_x + ", " + bim_offset_y);                                

                                g.drawImage(smallImage, bim_offset_x, bim_offset_y, null);

                                bi = null;

                        }

                }

                wholeImage = null;

                System.gc();

        }

        /**

         * @return the raster data type, that is, the data type of the individual bands.

         */

        public int getRasterDataType() {

                return DataBuffer.TYPE_BYTE;

        }

        /**

         * @return the data associated with a specified pixel and a particular band

         * 

         * @param x the x coordinate of the pixel

         * @param y the y coordinate of the pixel

         * @param band the 0-based band index

         */

        public Object getData(int x, int y, int band) {

                return null;

        }

        /**

         * Gets the RGB values of the pixel of interest

         * 

         * @param wcx x coordinate in map units

         * @param wcy y coordinate in map units

         * 

         * @return array of RGB values of the pixel of interest

         */

        public int[] getPixel(double wcx, double wcy) {

                int[] resp = new int[3];

                try {

                        Point2D.Double wpoint = new Point2D.Double(wcx, wcy);

                        Point2D.Double image_point = new Point2D.Double(0, 0);

                        at.inverseTransform(wpoint, image_point);

                        int scrx = (int) Math.round(image_point.getX());

                        int scry = (int) Math.round(image_point.getY());

                        Image wholeImage = getImageFromBytes(imageFileBytes);

                        BufferedImage bi = Utils.createBufferedImage(5, 5);

                        bi.getGraphics().drawImage(wholeImage, -scrx, -scry, null);

                        int pixel = bi.getRGB(0, 0);

                        resp[0] = (pixel >> 16) & 0xff;

                        resp[1] = (pixel >> 8) & 0xff;

                        resp[2] = pixel & 0xff;

                } catch (Throwable e) {

                        logger.error("While getting pixel bands: " + e.getMessage());

                        resp[0] = -1;

                        resp[1] = -1;

                        resp[2] = -1;

                }

                return resp;

        }

        /**

         * @return the driver name

         */

        public String getName() {

                return "WKR raster driver";

        }

        /**

         * return raster coords + view pixels coords

         */

        private int[] getRasterTansformation(Rectangle2D viewRect, Rectangle2D imageExt,

                        int vw, int imgw, int imgh) {

                if (Utils.rectanglesItersect(viewRect, imageExt)) {

                        double units_per_pixel_in_view = viewRect.getWidth() / (1.0 * vw);

                        double units_per_pixel_in_raster = imageExt.getWidth() / (1.0 * imgw);

                        if (units_per_pixel_in_raster > units_per_pixel_in_view) {

                                // zoom in

                                Rectangle2D interse = new Rectangle2D.Double();

                                Rectangle2D.intersect(viewRect, imageExt, interse);

                                double interse_map_x_offset_to_img = interse.getMinX() - imageExt.getMinX();

                                double interse_map_y_offset_to_img = imageExt.getMaxY() - interse.getMaxY();

                                int interse_offset_in_img_x =

                                        Math.round((float) (interse_map_x_offset_to_img / units_per_pixel_in_raster));

                                int interse_offset_in_img_y =

                                        Math.round((float) (interse_map_y_offset_to_img / units_per_pixel_in_raster));

                                int inserse_pix_w = 

                                        Math.round((float) (interse.getWidth() / units_per_pixel_in_raster));

                                int inserse_pix_h = 

                                        Math.round((float) (interse.getHeight() / units_per_pixel_in_raster));

                                double interse_map_x_offset_to_view = interse.getMinX() - viewRect.getMinX();

                                double interse_map_y_offset_to_view = viewRect.getMaxY() - interse.getMaxY();

                                int interse_offset_in_view_x =

                                        Math.round((float) (interse_map_x_offset_to_view / units_per_pixel_in_view));

                                int interse_offset_in_view_y =

                                        Math.round((float) (interse_map_y_offset_to_view / units_per_pixel_in_view));

                                int interse_final_w =

                                        Math.round((float) (interse.getWidth() / units_per_pixel_in_view));

                                int interse_final_h =

                                        Math.round((float) (interse.getHeight() / units_per_pixel_in_view));

                                int[] resp = new int[8];

                                resp[0] = interse_offset_in_img_x;

                                resp[1] = interse_offset_in_img_y;

                                if (inserse_pix_w == 0) inserse_pix_w = 1;

                                resp[2] = inserse_pix_w;

                                if (inserse_pix_h == 0) inserse_pix_h = 1;

                                resp[3] = inserse_pix_h;

                                if (interse_final_w == 0) interse_final_w = 1;

                                resp[4] = interse_final_w;

                                if (interse_final_h == 0) interse_final_h = 1;

                                resp[5] = interse_final_h;

                                resp[6] = interse_offset_in_view_x;

                                resp[7] = interse_offset_in_view_y;

                                return resp;

                        } else {

                                // downsample

                                int[] resp = new int[4];

                                double raster_map_x_offset_to_view = imageExt.getMinX() - viewRect.getMinX();

                                double raster_map_y_offset_to_view = viewRect.getMaxY() - imageExt.getMaxY();

                                double raster_pix_x_offset_to_view =

                                        raster_map_x_offset_to_view / units_per_pixel_in_view;

                                double raster_pix_y_offset_to_view =

                                        raster_map_y_offset_to_view / units_per_pixel_in_view;

                                resp[0] = Math.round((float) raster_pix_x_offset_to_view);

                                resp[1] = Math.round((float) raster_pix_y_offset_to_view);

                                resp[2] = Math.round(

                                                (float) ((1.0 * imgw) * units_per_pixel_in_raster / units_per_pixel_in_view)

                                                );

                                if (resp[2] == 0) resp[2] = 1;

                                resp[3] = Math.round(

                                                (float) ((1.0 * imgh) * units_per_pixel_in_raster / units_per_pixel_in_view)

                                                );

                                if (resp[3] == 0) resp[3] = 1;

                                return resp;

                        }

                } else {

                        return null;

                }

        }

        private static String[] getWorldFileExtensions(String ext) {

                if ((ext.compareToIgnoreCase("jpg") == 0) || (ext.compareToIgnoreCase("jpeg") == 0)) {

                        String[] resp = {"wld", "jgw", "jpw"};

                        return resp;

                }

                if ((ext.compareToIgnoreCase("gif") == 0) || (ext.compareToIgnoreCase("png") == 0)) {

                        String[] resp = {"wld"};

                        return resp;

                } else {

                        return null;

                }

        }

        /**

         * @return the raster file full path

         */

        public String getFilePath() {

                return path;

        }

}