Application: gvSIG desktop

package org.gvsig.raster.util;

import java.awt.Dimension;

import java.awt.geom.AffineTransform;

import java.awt.geom.Dimension2D;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import org.gvsig.raster.buffer.RasterBuffer;

import org.gvsig.raster.datastruct.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){

            if(proj == null)

                    return "";

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

        return new Extent(vx, vy, vx2, vy2);

    }

    /**

     * 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. Este m?todo 

     * tiene en cuenta la rotaci?n aplicada al raster por lo que no ajustamos a un extent sino

     * a una matriz de transformaci?n. Esta tiene los par?metros de traslaci?n, rotaci?n y

     * escalado del raster destino. Esta matriz transforma coordenadas pixel a real y viceversa.

     * 

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

     * @param AffineTransform Matriz de transformaci?n del raster destino

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

     */

    public static Extent calculateAdjustedView(Extent extToAdj, AffineTransform at, Dimension2D dim) { 

            //Obtenemos los cuatro puntos de la petici?n de origen

                Point2D ul = new Point2D.Double(extToAdj.getULX(), extToAdj.getULY());

                Point2D lr = new Point2D.Double(extToAdj.getLRX(), extToAdj.getLRY());

                //Los convertimos a coordenadas pixel con la matriz de transformaci?n

                try {

                        at.inverseTransform(ul, ul);

                        at.inverseTransform(lr, lr);

                } catch (NoninvertibleTransformException e) {

                        return extToAdj;

                }

                //Ajustamos a la dimensi?n del raster en pixeles

        if (ul.getX() < 0)

            ul.setLocation(0, ul.getY());

        if (ul.getX() >= dim.getWidth())

            ul.setLocation(dim.getWidth(), ul.getY());

        if (ul.getY() < 0)

            ul.setLocation(ul.getX(), 0);

        if (ul.getY() >= dim.getHeight())

            ul.setLocation(ul.getX(), dim.getHeight());

        if (lr.getX() < 0)

                lr.setLocation(0, lr.getY());

        if (lr.getX() >= dim.getWidth())

                lr.setLocation(dim.getWidth(), lr.getY());

        if (lr.getY() < 0)

                lr.setLocation(lr.getX(), 0);

        if (lr.getY() >= dim.getHeight())

                lr.setLocation(lr.getX(), dim.getHeight());

        //Lo convertimos a coordenadas reales nuevamente

        at.transform(ul, ul);

        at.transform(lr, lr);

        return new Extent(ul, lr);

    }

    /**

     * 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.getMax().getX()) || (e1.getMin().getY() > ref.getMax().getY()) ||

                            (e1.getMax().getX() < ref.getMin().getX()) || (e1.getMax().getY() < ref.getMin().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();

    }

    /**

         * Crea un fichero de georeferenciaci?n (world file) para un dataset determinado

         * @param GdalDriver

         * @param fileName Nombre completo del fichero de raster

         * @param Extent 

         * @param pxWidth Ancho en p?xeles

         * @param pxHeight Alto en p?xeles

         * @return

         * @throws IOException

         */

        public static void createWorldFile(String fileName, Extent ext, int pxWidth, int pxHeight) throws IOException {

            File tfw = null;

            String extWorldFile = ".wld";

            if(fileName.endsWith("tif"))

                    extWorldFile = ".tfw";

            if(fileName.endsWith("jpg") || fileName.endsWith("jpeg"))

                    extWorldFile = ".jpgw";

            tfw = new File(fileName.substring(0, fileName.lastIndexOf(".")) + extWorldFile);

            //Generamos un world file para gdal

            DataOutputStream dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(tfw)) );

            dos.writeBytes((ext.getMax().getX() - ext.getMin().getX()) / pxWidth + "\n");

            dos.writeBytes("0.0\n");

            dos.writeBytes("0.0\n");

            dos.writeBytes((ext.getMin().getY() - ext.getMax().getY()) / pxHeight + "\n");

            dos.writeBytes("" + ext.getMin().getX() + "\n");

            dos.writeBytes("" + ext.getMax().getY() + "\n");

            dos.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 MathUtils.format(gBytes, 1) + "G";

                if(mBytes > 0)

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

                if(kBytes > 0)

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

                if(bytes != 0)

                        return ((int)bytes) + "";

                return "";

    }

    /**

     * Obtiene la extensi?n del fichero a partir de su nombre.

     * @param file Nombre o ruta del fichero

     * @return Cadena con la extensi?n que representa el tipo de fichero.

     */

    public static String getExtensionFromFileName(String file) {

            return file.toLowerCase().substring(file.lastIndexOf(".") + 1);

    }

        /**

         * Obtiene la codificaci?n de un fichero XML

         * @param file Nombre del fichero XML

         * @return Codificaci?n

         */

        public static String readFileEncoding(String file){

                FileReader fr;

                String encoding = null;

                try {

                        fr = new FileReader(file);

                    BufferedReader br = new BufferedReader(fr);

                    char[] buffer = new char[100];

                    br.read(buffer);

                    StringBuffer st = new StringBuffer(new String(buffer));

                    String searchText = "encoding=\"";

                    int index = st.indexOf(searchText);

                    if (index >- 1) {

                            st.delete(0, index+searchText.length());

                            encoding = st.substring(0, st.indexOf("\""));

                    }

                    fr.close();

            } catch(FileNotFoundException ex)        {

                    ex.printStackTrace();

            } catch (IOException e) {

                        e.printStackTrace();

                }

            return encoding;

        }

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

    //VARIOS

        /**

         * Formatea el tiempo en milisegundos devolviendo un String en formato .

         * dias, horas, minutos y segundos.

         * @param time Tiempo en milisegundos

         */

        public static String formatTime(long time) {

                int days = 0, hours = 0, minuts = 0, seconds = (int)(time / 1000D);

                if(seconds >= 60){

                        minuts = (int)(seconds / 60);

                        seconds = (int)(seconds - (minuts * 60));

                        if(minuts >= 60){

                                hours = (int)(minuts / 1024);

                                minuts = (int)(minuts - (hours * 60));

                        }

                }

                StringBuffer s = new StringBuffer();

                if(hours != 0)

                        s.append(hours+" H ");

                if(minuts != 0)

                        s.append(minuts+" Min ");

                if(seconds != 0)

                        s.append(seconds+" Sec ");

                return s.toString();

        }        

}