| 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.util.graph2d;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.awt.image.FilteredImageSource;

import megamek.client.ui.AWT.util.RotateFilter;

import org.apache.log4j.Logger;

import es.prodevelop.gvsig.mobile.fmap.driver.raster.ecw.EcwReader;

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

/**

 * Utility class to perform graphic rotations. Currently not used.

 * 

 * @see java.awt.geom.AffineTransform

 * 

 * @author jcarras

 * @author jldominguez

 *

 */

public class RotationUtils {

        private static Logger logger = Logger.getLogger(RotationUtils.class.getName());

        public static void drawRotatedText(

                        Graphics2D g,

                        String text,

                        Color c,

                        int x,

                        int y,

                        double alpha_degrees) {

                if (alpha_degrees > Math.PI/2 && alpha_degrees <-Math.PI/2){

                        logger.error("Angle not as spected");

                        //Try to handle with this

                        while(alpha_degrees>Math.PI/2)

                                alpha_degrees -= Math.PI;

                        while(alpha_degrees<-Math.PI/2)

                                alpha_degrees += Math.PI;

                }

                int w = g.getFontMetrics().stringWidth(text);

                int h = g.getFontMetrics().getHeight();

                if (Utils.USING_PDA)

                        h-= 4;

                Image img = Utils.createBufferedImage(w+h*2, w+h*2);

                Graphics g2 = img.getGraphics();

                g2.setColor(Color.black);

                g2.fillRect(0,0,w+2*h, w+2*h);

                g2.setColor(Color.WHITE);

                if (Utils.USING_PDA){

                        g2.drawString(text, h, w/2 );

                        //g2.drawLine(0,w/2,h+w+h,w/2);

                } else {

                        g2.drawString(text, h, w/2+h );

                        //g2.drawLine(0,w/2+h,h+w+h,w/2+h);

                }

                RotateFilter filt = new RotateFilter(alpha_degrees,c);

                Image img2 = Toolkit.getDefaultToolkit().createImage(

                                new FilteredImageSource(img.getSource(),filt));

                /*

                g.drawImage(img2,

                                (int)(x-(w/2+h-Math.cos(alpha_degrees))),

                                (int)(y-(w/2+h+h/2+Math.sin(alpha_degrees))),

                                null);*/

                int x1 = (int)(x-(w/2+h-(w/2)*Math.cos(alpha_degrees)));

                if (alpha_degrees>=0)

                        x1 = (int)(x-(w/2+h-(w/2)*Math.cos(alpha_degrees)));

                int y1= (int)(y-(w/2+h+(w/2)*Math.sin(alpha_degrees)));

                if (alpha_degrees>=0)

                        y1= (int)(y-(w/2+h+(w/2)*Math.sin(alpha_degrees)));

                g.drawImage(img2,

                                x1,

                                y1,

                                null);

        }

        public static void drawRotatedText2(

                        Graphics2D g,

                        String text,

                        Color c,

                        int x,

                        int y,

                        double alpha_degrees) {

                if (alpha_degrees > Math.PI/2 && alpha_degrees <-Math.PI/2){

                        logger.error("Angle not as spected");

                        //Try to handle with this

                        while(alpha_degrees>Math.PI/2)

                                alpha_degrees -= Math.PI;

                        while(alpha_degrees<-Math.PI/2)

                                alpha_degrees += Math.PI;

                }

                int w = g.getFontMetrics().stringWidth(text);

                int h = g.getFontMetrics().getHeight();

                Image img = Utils.createBufferedImage(w*2+h*2, w*2+h*2);

                Graphics g2 = img.getGraphics();

                g2.setColor(Color.black);

                g2.fillRect(0,0,w*2+h, w*2+h);

                g2.setColor(Color.WHITE);

                if (Utils.USING_PDA)

                        g2.drawString(text, w+h, w);

                else

                        g2.drawString(text, w+h, w+h);

                RotateFilter filt = new RotateFilter(alpha_degrees,c);

                Image img2 = Toolkit.getDefaultToolkit().createImage(

                                new FilteredImageSource(img.getSource(),filt));

                g.drawImage(img2,x-w-h,y-w-h,null);

        }

        public static void drawRotatedText3(

                        Graphics2D g,

                        String text,

                        Color c,

                        int x,

                        int y,

                        double alpha_degrees) {

                int w = g.getFontMetrics().stringWidth(text);

                int h = g.getFontMetrics().getHeight();

                BufferedImage img = Utils.createBufferedImage(w, h);

                Graphics g2 = img.getGraphics();

                // g2.setColor(Color.BLACK);

                // g2.fillRect(0, 0, w, h);

                g2.setColor(Color.WHITE);

                g2.drawString(text, 0, h - 1);

                int[] input_raster = img.getRGB(0, 0, w, h, null, 0, w);

                int red = c.getRed();

                int green = c.getGreen();

                int blue = c.getBlue();

                double alpha_radians = alpha_degrees * Math.PI / 180.0;

                double inc_alpha = Math.atan((1.0 * h) / (1.0 * w));

                int x_offset = getRotatedImageXOffset(w, h, alpha_radians);

                int y_offset = getRotatedImageYOffset(w, h, alpha_radians, inc_alpha);

                Image rotated_img = null;

                if (Utils.USING_PDA) {

                        byte[] rotated_png = getRotatedPngBytes(

                                input_raster,

                                w, h,

                                alpha_radians,

                                inc_alpha,

                                red, green, blue,

                                x_offset);

                        rotated_img = Toolkit.getDefaultToolkit().createImage(rotated_png);

                } else {

                        rotated_img = getRotatedImage(

                                        input_raster,

                                        w, h,

                                        alpha_radians,

                                        inc_alpha,

                                        red, green, blue,

                                        x_offset);

                }

                g.drawImage(rotated_img, x + x_offset, y + y_offset, null);

        }

        private static byte[] getRotatedPngBytes(

                        int[] input_raster,

                        int w, int h,

                        double r,

                        double inc_r,

                        int red, int green, int blue,

                        int x_off) {

                int out_w = (int) Math.round(w * Math.cos(r) + h * Math.sin(r));

                double m = Math.sqrt(w * w + h * h);

                int out_h = (int) Math.round(m * Math.sin(r + inc_r));

                int[] out_raster = rotate(

                                input_raster, w, h, r, inc_r, out_w, out_h, red, green, blue, x_off);

                return EcwReader.paintArray(out_raster, out_w, out_h, 0, false);

        }

        private static Image getRotatedImage(

                        int[] input_raster,

                        int w, int h,

                        double r,

                        double inc_r,

                        int red, int green, int blue,

                        int x_off) {

                int out_w = (int) Math.round(w * Math.cos(r) + h * Math.sin(r));

                double m = Math.sqrt(w * w + h * h);

                int out_h = (int) Math.round(m * Math.sin(r + inc_r));

                int[] out_raster = rotate(

                                input_raster, w, h, r, inc_r, out_w, out_h, red, green, blue, x_off);

                BufferedImage resp = new BufferedImage(out_w, out_h, 1);

                resp.setRGB(0, 0, out_w, out_h, out_raster, 0, out_w);

                return resp;                

        }

        private static int getBitmapBlueValue(int[] bit_map, int w, int h, int x, int y) {

                if (x >= w) return 0; 

                if (x < 0) return 0; 

                if (y >= h) return 0; 

                if (y < 0) return 0;

                return bit_map[w * y + x] & 0xff;

        }

    private static int rotatePixel(

                    int x, int y,

                    int[] in_raster,

                    int in_w, int in_h,

                    double m00, double m01, double m10, double m11,

                    int red, int green, int blue,

                    int x_off) {

        double rx = (x + x_off) * m00 - y * m10;

        double ry = (x + x_off) * m01 + y * m11;

        return pixelBilinear(rx, ry, in_raster, in_w, in_h, red, green, blue);

    }

        private static int pixelBilinear(

                        double rx,

                        double ry,

                        int[] in_raster,

                        int in_w, int in_h,

                        int red, int green, int blue) {

                int fx = (int) Math.floor(rx);

                int fy = (int) Math.floor(ry);

                int b0 = getBitmapBlueValue(in_raster, in_w, in_h, fx    , fy    );

                int b1 = getBitmapBlueValue(in_raster, in_w, in_h, fx + 1, fy    );

                int b2 = getBitmapBlueValue(in_raster, in_w, in_h, fx    , fy + 1);

                int b3 = getBitmapBlueValue(in_raster, in_w, in_h, fx + 1, fy + 1);

                if ((b0 == 0) && (b1 == 0) && (b2 == 0) && (b3 == 0)) return 0;  

                double xv = rx - fx;

                double yv = ry - fy;

                double mul0 = (1.0 - xv) * (1.0 - yv);

                double mul1 = xv * (1.0 - yv);

                double mul2 = (1.0 - xv) * yv;

                double mul3 = xv * yv;        

                int transp = (int) Math.round(

                                mul0 * b0

                                + mul1 * b1

                                + mul2 * b2

                                + mul3 * b3);

                return transp * 16777216 + red * 65536 + green * 256 + blue;

        }

        private static int[] rotate(

                        int[] input_raster,

                        int w, int h,

                        double r, double inc_r,

                        int out_w, int out_h,

                        int red, int green, int blue,

                        int x_off) {

                AffineTransform at = AffineTransform.getRotateInstance(-r);

                double m00 = at.getScaleX();

                double m01 = at.getShearX();

                double m10 = at.getShearY();

                double m11 = at.getScaleY();

                // double the_sin = 

                int[] resp = new int[out_w * out_h];

                int inv_j = 0;

                for (int j=0; j<out_h; j++) {

                        inv_j = out_h - 1 - j; 

                        for (int i=0; i<out_w; i++) {

                                resp[out_w * inv_j + i] = rotatePixel(

                                                i, inv_j,

                                                input_raster,

                                                w, h,

                                                m00, m01, m10, m11,

                                                red, green, blue,

                                                x_off);

                        }

                }

                return resp;

        }

        private static int getRotatedImageXOffset(int w, int h, double alpha_rad) {

                return -(int) Math.round(h * Math.sin(alpha_rad));

        }

        private static int getRotatedImageYOffset(

                        int w, int h,

                        double alpha_rad,

                        double inc_alpha) {

                double hipot = Math.sqrt(w * w + h * h);

                return -(int) Math.round(hipot * Math.sin(alpha_rad + inc_alpha));

        }

}