Application: gvSIG desktop

package org.cresques.util;

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.cresques.io.data.RasterBuf;

import org.cresques.px.Extent;

import es.gva.cit.jgdal.Gdal;

/**

 * 

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

 *

 */

public class Utilities {

        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  RasterBuf.TYPE_BYTE;//GDT_BYTE 

                case 2://GDT_UInt16

                case 8://GDT_CInt16

                case 3:return RasterBuf.TYPE_SHORT;//GDT_Int16        

                case 4://GDT_UInt32

                case 9://GDT_CInt32

                case 5:return RasterBuf.TYPE_INT;//GDT_Int32

                case 10://GDT_CFloat32

                case 6:return RasterBuf.TYPE_FLOAT;//GDT_Float32

                case 11://GDT_CFloat64

                case 7:return RasterBuf.TYPE_DOUBLE;//GDT_Float64

                }

            return RasterBuf.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 RasterBuf.TYPE_BYTE:return Gdal.GDT_Byte;

                case RasterBuf.TYPE_USHORT: return Gdal.GDT_UInt16;

                case RasterBuf.TYPE_SHORT: return Gdal.GDT_Int16;

                case RasterBuf.TYPE_INT: return Gdal.GDT_Int32;

                case RasterBuf.TYPE_FLOAT: return Gdal.GDT_Float32;

                case RasterBuf.TYPE_DOUBLE: return Gdal.GDT_Float64;

                case RasterBuf.TYPE_UNDEFINED: return Gdal.GDT_Unknown;

                case RasterBuf.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 RasterBuf.TYPE_UNDEFINED;//INVALID

                case 1://UINT8 

                case 2:return  RasterBuf.TYPE_BYTE;//SINT8

                case 3://UINT16

                case 4:return RasterBuf.TYPE_SHORT;//SINT16        

                case 5://UINT32

                case 6:return RasterBuf.TYPE_INT;//SINT32        

                case 7:return RasterBuf.TYPE_FLOAT;//FLOAT32

                case 8:return RasterBuf.TYPE_DOUBLE;//FLOAT64

                }

            return RasterBuf.TYPE_UNDEFINED;

    }

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

    //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()));

    }

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

    //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();

    }

}