| gvSIG desktop 1

package org.gvsig.raster.util;

import java.awt.Dimension;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.gvsig.raster.dataaccess.buffer.RasterBuffer;

import org.gvsig.raster.shared.Extent;

import es.gva.cit.jgdal.Gdal;

/**

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 *

 */

public class RasterUtilities {

        public static final        int MAX_BYTE_BIT_VALUE        = 255;

        public static final        int MAX_SHORT_BIT_VALUE        = 65535;

    //---------------------------------------------------------------

    //TIPOS DE DATOS

    /**

     * Conversi?n de los tipos de datos de gdal a los tipos de datos de

     * RasterBuf

     * @param gdalType Tipo de dato de gdal

     * @return Tipo de dato de RasterBuf

     */

    public static int getRasterBufTypeFromGdalType(int gdalType){

            switch(gdalType){

                case 1:return  RasterBuffer.TYPE_BYTE;//GDT_BYTE

                case 2://GDT_UInt16

                case 8://GDT_CInt16

                case 3:return RasterBuffer.TYPE_SHORT;//GDT_Int16

                case 4://GDT_UInt32

                case 9://GDT_CInt32

                case 5:return RasterBuffer.TYPE_INT;//GDT_Int32

                case 10://GDT_CFloat32

                case 6:return RasterBuffer.TYPE_FLOAT;//GDT_Float32

                case 11://GDT_CFloat64

                case 7:return RasterBuffer.TYPE_DOUBLE;//GDT_Float64

                }

            return RasterBuffer.TYPE_UNDEFINED;

    }

    /**

     * Conversi?n de los tipos de datos de RasterBuf en los de gdal.

     * @param rasterBufType Tipo de dato de RasterBuf

     * @return Tipo de dato de Gdal

     */

    public static int getGdalTypeFromRasterBufType(int rasterBufType){

            switch(rasterBufType){

                case RasterBuffer.TYPE_BYTE:return Gdal.GDT_Byte;

                case RasterBuffer.TYPE_USHORT: return Gdal.GDT_UInt16;

                case RasterBuffer.TYPE_SHORT: return Gdal.GDT_Int16;

                case RasterBuffer.TYPE_INT: return Gdal.GDT_Int32;

                case RasterBuffer.TYPE_FLOAT: return Gdal.GDT_Float32;

                case RasterBuffer.TYPE_DOUBLE: return Gdal.GDT_Float64;

                case RasterBuffer.TYPE_UNDEFINED: return Gdal.GDT_Unknown;

                case RasterBuffer.TYPE_IMAGE: return Gdal.GDT_Byte;

                }

            return Gdal.GDT_Unknown;

    }

    /**

     * Conversi?n de los tipos de datos de MrSID a los tipos de datos de

     * RasterBuf

     * @param mrsidType Tipo de dato de MrSID

     * @return Tipo de dato de RasterBuf

     */

    public static int getRasterBufTypeFromMrSIDType(int mrsidType){

            switch(mrsidType){

            case 0:return RasterBuffer.TYPE_UNDEFINED;//INVALID

                case 1://UINT8

                case 2:return  RasterBuffer.TYPE_BYTE;//SINT8

                case 3://UINT16

                case 4:return RasterBuffer.TYPE_SHORT;//SINT16

                case 5://UINT32

                case 6:return RasterBuffer.TYPE_INT;//SINT32

                case 7:return RasterBuffer.TYPE_FLOAT;//FLOAT32

                case 8:return RasterBuffer.TYPE_DOUBLE;//FLOAT64

                }

            return RasterBuffer.TYPE_UNDEFINED;

    }

    /**

     * Obtiene el n?mero de bytes que ocupa un tipo de dato concreto.

     * Los tipos de datos son los utilizados en RasterBuffer

     * @param rasterBufType Tipo de dato del que se solicita el n?mero de bytes ocupados

     * @return

     */

    public static int getBytesFromRasterBufType(int rasterBufType){

            switch(rasterBufType){

                case RasterBuffer.TYPE_BYTE:return 1;

                case RasterBuffer.TYPE_USHORT:

                case RasterBuffer.TYPE_SHORT: return 2;

                case RasterBuffer.TYPE_INT:

                case RasterBuffer.TYPE_FLOAT:

                case RasterBuffer.TYPE_IMAGE: return 4;

                case RasterBuffer.TYPE_DOUBLE: return 8;

                }

            return 0; //TYPE_UNDEFINED

    }

    /**

     * Convierte un tipo de dato a cadena

     * @param type Tipo de dato

     * @return cadena  que representa el tipo de dato

     */

    public static String typesToString(int type) {

        switch (type) {

        case RasterBuffer.TYPE_IMAGE:

            return new String("Image");

        case RasterBuffer.TYPE_BYTE:

            return new String("Byte");

        case RasterBuffer.TYPE_DOUBLE:

            return new String("Double");

        case RasterBuffer.TYPE_FLOAT:

            return new String("Float");

        case RasterBuffer.TYPE_INT:

                return new String("Integer");

        case RasterBuffer.TYPE_USHORT:

        case RasterBuffer.TYPE_SHORT:

            return new String("Short");

        }

        return null;

    }

    /**

     * Parseo de las proyecciones que genera gdal para meter espaciados y saltos de l?nea HTML

     * @param proj Proyecci?n

     * @return Cadena con la proyecci?n parseada

     */

    public static String parserGdalProj(String proj){

            String[] list = proj.split(",");

            int level = 0;

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

                    if(list[i].indexOf("[") >= 0){

                            level ++;

                            String spaces = "";

                            for(int j = 0; j < level; j++)

                                    spaces += "  ";

                            list[i] = spaces + list[i];

                    }

                    if(list[i].indexOf("]]") >= 0)

                            level = level - 2;

                    else if(list[i].indexOf("]") >= 0)

                            level --;

            }

            StringBuffer str = new StringBuffer();

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

                    if(i < list.length){

                            if(i + 1 < list.length && list[i + 1].indexOf("[") >= 0)

                                    str.append(list[i] + ",<BR>");

                            else

                                    str.append(list[i] + ",");

                    }

            }

            return str.toString();

    }

    //---------------------------------------------------------------

    //ESPACIO DE COLOR

    /**

     * Descompone un entero que representa un ARGB en sus 4 valores byte

     * Obtiene un array de 4 elementos donde el elemento 0 es el Rojo, el 1 es el

     * verde, el 2 el azul y el 3 el alpha.

     * @param rgb Entero con el valor ARGB a descomponer;

     * @return Array de cuatro elementos

     */

    public static byte[] getARGBFromIntToByteArray(int rgb){

            byte[] b = new byte[4];

            b[0] = (byte)((rgb & 0x00ff0000) >> 16);

            b[1] = (byte)((rgb & 0x0000ff00) >> 8);

            b[2] = (byte)(rgb & 0x000000ff);

            b[3] = (byte)((rgb & 0xff000000) >> 24);

            return b;

    }

    /**

     * Descompone un entero que representa un ARGB en sus 4 valores byte

     * Obtiene un array de 4 elementos donde el elemento 0 es el Rojo, el 1 es el

     * verde, el 2 el azul y el 3 el alpha.

     * @param rgb Entero con el valor ARGB a descomponer;

     * @return

     */

    public static int[] getARGBFromIntToIntArray(int rgb){

            int[] i = new int[4];

            i[0] = (((rgb & 0x00ff0000) >> 16) & 0xff);

            i[1] = (((rgb & 0x0000ff00) >> 8) & 0xff);

            i[2] = ((rgb & 0x000000ff) & 0xff);

            i[3] = (((rgb & 0xff000000) >> 24) & 0xff);

            return i;

    }

    /**

     * Obtiene un entero con los valores ARGB pasados por par?metro

     * @param a Valor de alpha

     * @param r Valor del rojo

     * @param g Valor del verde

     * @param b Valor del azul

     * @return entero con la mezcla de valores

     */

    public static int getIntFromARGB(int a, int r, int g, int b){

              return (((a & 0xff) << 24) + ((r & 0xff) << 16) + ((g & 0xff) << 8) + (b & 0xff));

    }

    //---------------------------------------------------------------

    //CONVERSI?N DE COORDENADAS

    /**

     * Convierte una ventana en coordenadas del mundo real a sus coordenadas relativas en pixels teniendo

     * en cuenta que la coordenada superior izquierda es 0,0 y la inferior derecha es maxX y maY

     * @param extent Extent de la imagen original

     * @param widthPx Ancho en pixeles de la imagen original

     * @param heightPx Alto en pixeles de la imagen original

     * @param window Ventana en coordenadas reales a transportar a coordenadas pixel

     * @return Ventana en coordenadas pixel

     */

    public static Rectangle2D getPxRectFromMapRect(Rectangle2D extent, double widthPx, double heightPx, Rectangle2D window){

            double widthWC = extent.getWidth();

                double heightWC = extent.getHeight();

                double wWindowWC = Math.abs(window.getMaxX() - window.getMinX());

                   double hWindowWC = Math.abs(window.getMaxY() - window.getMinY());

                   double wWindowPx = ((wWindowWC * widthPx) /  widthWC);

                   double hWindowPx = ((hWindowWC * heightPx) /  heightWC);

                   double initDistanceX = Math.abs(window.getMinX() - extent.getMinX());

                   double initDistanceY = Math.abs(window.getMaxY() - extent.getMaxY());

                   double initPxX = ((initDistanceX * widthPx) /  widthWC);

                   double initPxY = ((initDistanceY * heightPx) /  heightWC);

                   Rectangle2D pxRec = new Rectangle2D.Double(        initPxX,

                                                                                                           initPxY,

                                                                                                           wWindowPx,

                                                                                                           hWindowPx);

                   return pxRec;

    }

    /**

     * Convierte una ventana en coordenadas del mundo real a sus coordenadas relativas en pixels teniendo

     * en cuenta que la coordenada superior izquierda es 0,0 y la inferior derecha es maxX y maY

     * @param extent Extent de la imagen original

     * @param widthPx Ancho en pixeles de la imagen original

     * @param heightPx Alto en pixeles de la imagen original

     * @param window Ventana en coordenadas reales a transportar a coordenadas pixel

     * @return Ventana en coordenadas pixel

     */

    public static Rectangle2D getMapRectFromPxRect(Rectangle2D extent, double widthPx, double heightPx, Rectangle2D pxWindow){

                   double wWindowWC = ((pxWindow.getWidth() * extent.getWidth()) /  widthPx);

                   double hWindowWC = ((pxWindow.getHeight() * extent.getHeight()) /  heightPx);

                   double initWCX = extent.getMinX() + ((pxWindow.getMinX() * extent.getWidth()) /  widthPx);

                   double initWCY = extent.getMaxY() - ((pxWindow.getMinY() * extent.getHeight()) /  heightPx);

                   Rectangle2D mapRec = new Rectangle2D.Double(initWCX,

                                                                                                           initWCY - hWindowWC,

                                                                                                           wWindowWC,

                                                                                                           hWindowWC);

                   return mapRec;

    }

    /**

     * Convierte un punto en coordenadas del mundo a coordenadas pixel

     * @param p Punto a convertir

     * @param ext Extent completo de la imagen

     * @return Punto en coordenadas pixel

     */

    public static Point2D worldPointToRaster(Point2D p, Extent ext, int pxWidth, int pxHeight) {

            double x = p.getX() - ext.getMin().getX();

            double y = p.getY() - ext.getMin().getY();

            int pxX = (int)((x * pxWidth) / ext.width());

            int pxY = (int)((y * pxHeight) / ext.height());

            return new Point2D.Double(pxX, pxY);

    }

    /**

     * Ajusta la extensi?n pasada por par?metro a los valores m?ximos y m?nimos de la

     * imagen. Esto sirve para que la petici?n al driver nunca sobrepase los l?mites

     * de la imagen tratada aunque la vista donde se dibuje sea de mayor tama?o.

     *

     * @param imgExt Extent completo de la vista donde se va a dibujar.

     * @param extToAdj Extent a ajustar.

     * @return adjustedExtent Extent ajustado a m?ximos y m?nimos

     */

    public static Extent calculateAdjustedView(Extent extToAdj, Extent imgExt) {

        double vx = extToAdj.minX();

        double vy = extToAdj.minY();

        double vx2 = extToAdj.maxX();

        double vy2 = extToAdj.maxY();

        if (extToAdj.minX() < imgExt.minX())

            vx = imgExt.minX();

        if (extToAdj.minY() < imgExt.minY())

            vy = imgExt.minY();

        if (extToAdj.maxX() > imgExt.maxX())

            vx2 = imgExt.maxX();

        if (extToAdj.maxY() > imgExt.maxY())

            vy2 = imgExt.maxY();

        Extent adjustedExtent = new Extent(vx, vy, vx2, vy2);

        return adjustedExtent;

    }

    /**

     * Compara dos extents y devuelve true si son iguales

     * @param e1 Extent a comparar

     * @param e2 Extent a comparar

     * @return true si los extents pasados por par?metro son iguales y false si no lo son

     */

    public static boolean compareExtents(Extent e1, Extent e2){

            return ((e1.getMin().getX() == e2.getMin().getX()) && (e1.getMin().getY() == e2.getMin().getY()) &&

                            (e1.getMax().getX() == e2.getMax().getX())) && (e1.getMax().getY() == e2.getMax().getY());

    }

    /**

     * Comprueba si un extent est? contenido dentro de otro y devuelve true en este caso.

     * @param e1 Extent a comprobar si est? contenido en e2

     * @param e2 Extent sobre el que se comprueba si e1 est? dentro

     * @return true si e1 est? dentro de e1

     */

    public static boolean isInside(Extent e1, Extent e2){

            return ((e1.getMin().getX() >= e2.getMin().getX()) && (e1.getMin().getY() >= e2.getMin().getY()) &&

                            (e1.getMax().getX() <= e2.getMax().getX())) && (e1.getMax().getY() <= e2.getMax().getY());

    }

    /**

     * Comprueba si alguna parte de un extent est? fuera del extent que tenemos como referencia.

     * @param e1 Extent a comprobar si est? fuera

     * @param ref Extent de referencia

     * @return Devuelve true si alguna parte de e1 cae fuera de ref y false si no tiene ninguna fuera.

     */

    public static boolean isOutside(Extent e1, Extent ref){

            return ((e1.getMin().getX() < ref.getMin().getX()) || (e1.getMin().getY() < ref.getMin().getY()) ||

                            (e1.getMax().getX() > ref.getMax().getX()) || (e1.getMax().getY() > ref.getMax().getY()));

    }

        /**

         * Calcula los par?metros de un worl file a partir de las esquinas del raster.

         *    1. X pixel size A

         *    2. X rotation term D

         *    3. Y rotation term B

         *    4. Y pixel size E

         *    5. X coordinate of upper left corner C

         *    6. Y coordinate of upper left corner F

         * where the real-world coordinates x',y' can be calculated from

         * the image coordinates x,y with the equations

         *  x' = Ax + By + C and y' = Dx + Ey + F.

         *  The signs of the first 4 parameters depend on the orientation

         *  of the image. In the usual case where north is more or less

         *  at the top of the image, the X pixel size will be positive

         *  and the Y pixel size will be negative. For a south-up image,

         *  these signs would be reversed.

         *

         * You can calculate the World file parameters yourself based

         * on the corner coordinates. The X and Y pixel sizes can be

         *  determined simply by dividing the distance between two

         *  adjacent corners by the number of columns or rows in the image.

         *  The rotation terms are calculated with these equations:

         *

         *  # B = (A * number_of_columns + C - lower_right_x') / number_of_rows * -1

         *  # D = (E * number_of_rows + F - lower_right_y') / number_of_columns * -1

         *

         * @param corner (tl, tr, br, bl)

         * @return

         */

        public static double [] cornersToWorldFile(Point2D [] esq, Dimension size) {

                double a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;

                double x1 = esq[0].getX(), y1 = esq[0].getY();

                double x2 = esq[1].getX(), y2 = esq[1].getY();

                double x3 = esq[2].getX(), y3 = esq[2].getY();

                double x4 = esq[3].getX(), y4 = esq[3].getY();

                // A: X-scale

                a = Math.abs( Math.sqrt( (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))

                      / size.getWidth());

                // E: negative Y-scale

                e =  - Math.abs(Math.sqrt((x1 - x4) * (x1 - x4) +

                      (y1 - y4) * (y1 - y4)) / size.getHeight());

                // C, F: upper-left coordinates

                c = x1;

                f = y1;

                // B & D: rotation parameters

                b = (a * size.getWidth() + c - x3 ) / size.getHeight() * -1;

                d = (e * size.getHeight() + f - y3 ) / size.getWidth() * -1;

                double [] wf = {a, d, b, e, c, f};

                return wf;

        }

    //---------------------------------------------------------------

    //TRATAMIENTO DE FICHEROS

    /**

     * Copia de ficheros

     * @param pathOrig Ruta de origen

     * @param pathDst Ruta de destino.

     */

    public static void copyFile(String pathOrig, String pathDst)

            throws FileNotFoundException, IOException{

             InputStream in;

             OutputStream out;

             if(pathOrig == null || pathDst == null){

                     System.err.println("Error en path");

                     return;

             }

             File orig = new File(pathOrig);

             if(!orig.exists() || !orig.isFile() || !orig.canRead()){

                     System.err.println("Error en fichero de origen");

                     return;

             }

             File dest = new File(pathDst);

             String file = pathOrig.substring(pathOrig.lastIndexOf(File.separator), pathOrig.length());

             if(dest.isDirectory())

                     pathDst += file;

             in = new FileInputStream(pathOrig);

             out = new FileOutputStream(pathDst);

             byte[] buf = new byte[1024];

             int len;

             while ((len = in.read(buf)) > 0)

                        out.write(buf, 0, len);

             in.close();

             out.close();

    }

    /**

     * Formatea en forma de cadena un tama?o dado en bytes. El resultado

     * ser? una cadena con GB, MB, KB y B

     * @param size tama?o a formatear

     * @return cadena con la cantidad formateada

     */

    public static String formatFileSize(long size){

            double bytes = (double)size, kBytes = 0, mBytes = 0, gBytes = 0;

                if(size >= 1024){

                        kBytes = (double)(size / 1024D);

                        bytes = (int)(size - (((int)kBytes) * 1024));

                        if(kBytes >= 1024){

                                mBytes = (double)(((int)kBytes) / 1024D);

                                kBytes = (double)(((int)kBytes) - (((int)mBytes) * 1024));

                                if(mBytes >= 1024){

                                        gBytes = (int)(((int)mBytes) / 1024);

                                        mBytes = (int)(((int)mBytes) - (gBytes * 1024));

                                }

                        }

                }

                if(gBytes > 0)

                        return format(gBytes, 1) + "G";

                if(mBytes > 0)

                        return format(mBytes, 1) + "M";

                if(kBytes > 0)

                        return format(kBytes, 1) + "K";

                if(bytes != 0)

                        return ((int)bytes) + "";

                return "";

    }

    //---------------------------------------------------------------

    //VARIOS

    /**

         * Formats a double with an specified number of decimals.

         * @param num

         * Value to tail

         * @param n

         * Number of decimals

         * @return

         * The formatted double

         */

    public static double format(double num, int n){

            long m = (long)Math.pow(10, n);

        num *= m;

        long aux = ((long)num);

        num = (double)((double)aux / (double)m);

        return num;

    }

}