Comprobar si un archivo es una imagen

Question

estoy usando JAI y crear un archivo con:

PlanarImage img = JAI.create("fileload", myFilename); 

puedo comprobar antes de esa línea si existe el archivo. ¿Pero cómo puedo verificar si el archivo es un archivo .bmp o .tiff o un archivo de imagen?

¿Alguien sabe?

Answer 1

El proyecto Imagemagick tiene utilidades para identificar la imagen y hay una capa Java para ImageMagick llama JMagick que creo que es posible que desee considerar en lugar de reinventar la rueda:

http://www.jmagick.org

estoy usando ImageMagick todo el tiempo, incluyendo su función desde la línea de comandos "identificar" y nunca fallado una vez para identificar una imagen.

Ya en los días en que necesitaba absolutamente esa característica y JMagick aún no existía, solía usar Runtime.exec() ImageMagick identify comando de Java y funcionó a la perfección.

Hoy en día que existe JMagick esto probablemente ya no sea necesario (pero aún no lo he probado con JMagick).

Nota que da mucho más que sólo el formato, por ejemplo:

$ identify tmp3.jpg 
tmp3.jpg JPEG 1680x1050 1680x1050+0+0 DirectClass 8-bit 293.582kb 

$ identify tmp.png 
tmp.png PNG 1012x900 1012x900+0+0 DirectClass 8-bit 475.119kb 

Answer 2

La única forma (semi) confiable de determinar el contenido de un archivo es abrirlo y leer los primeros caracteres. Luego puede usar un conjunto de pruebas como las implementadas en el comando de archivo Unix para adivinar los contenidos del archivo.

Answer 3

Usted podría utilizar DROID, una herramienta para la identificación de formato de archivo que también ofrece una API de Java, que se utilizará más o menos así:

AnalysisController controller = new AnalysisController(); 
controller.readSigFile(signatureFileLocation); 
controller.addFile(fileToIdentify.getAbsolutePath()); 
controller.runFileFormatAnalysis(); 
Iterator<IdentificationFile> it = controller.getFileCollection().getIterator(); 

Documentación sobre el uso de la API es más bien escasa, pero se puede tener una mira this working example (la parte interesante está en el método identifyOneBinary).

Answer 4

Al comienzo de los archivos, hay una secuencia de caracteres identificadores. Por ejemplo, los archivos JPEG comienzan con FF D8 FF.

Puede verificar esta secuencia en su programa, pero no estoy seguro de si esto funciona para cada archivo.

Para obtener información sobre la identificación de caracteres que se pueden echar un vistazo a http://filext.com

Answer 5

Ampliando la respuesta de Birkan, hay una lista de 'números mágicos' disponible aquí:

http://www.astro.keele.ac.uk/oldusers/rno/Computing/File_magic.html

Acabo de comprobar un archivo BMP y TIFF (ambos recién creados en Windows XP/Paint), y parecen ser correctos:

First two bytes "42 4d" -> BMP 
First four bytes "4d 4d 00 2a" -> TIFF 

Utilicé VIM para editar los archivos y luego herramientas | Convierta a Hex, pero también puede usar 'od -c' o algo similar para verificarlos.

Como completa a un lado, que era un poco divertido cuando me enteré de los números mágicos utilizados para las clases Java compiladas: 'ca ba Fe sean' - 'café nena' :)

Answer 6

intente utilizar el estándar JavaBeans Activation Framework (JAF)

con el JavaBeans Activation Framework extensión estándar, los desarrolladores que utilizan la tecnología Java pueden aprovechar los servicios estándar para determinar el tipo de una pieza arbitraria de datos, encapsular el acceso al mismo, descubrir las operaciones disponibles en él, y para crear una instancia del bean apropiado para realizar dicha (s) operación (es). Por ejemplo, si un navegador obtiene una imagen JPEG, este marco permitiría que el navegador identifique esa secuencia de datos como una imagen JPEG, y de ese tipo, el navegador podría ubicar e instanciar un objeto que podría manipular, o ver eso imagen.

Answer 7

intente utilizar el ancho de la imagen:

boolean isImage(String image_path){ 
    Image image = new ImageIcon(image_path).getImage(); 
    if(image.getWidth(null) == -1){ 
     return false; 
    } 
    else{ 
     return true; 
    } 
} 

si la anchura es de -1 a continuación, no es una imagen.

Answer 8

Para decir si algo es un png, he usado este fragmento a continuación en Android java.

public CompressFormat getCompressFormat(Context context, Uri fileUri) throws IOException { 
    // create input stream 
    int numRead; 
    byte[] signature = new byte[8]; 
    byte[] pngIdBytes = { -119, 80, 78, 71, 13, 10, 26, 10 }; 
    InputStream is = null; 

    try { 
     ContentResolver resolver = context.getContentResolver(); 
     is = resolver.openInputStream(fileUri); 

     // if first 8 bytes are PNG then return PNG reader 
     numRead = is.read(signature); 

     if (numRead == -1) 
      throw new IOException("Trying to reda from 0 byte stream"); 

    } finally { 
     if (is != null) 
      is.close(); 
    } 

    if (numRead == 8 && Arrays.equals(signature, pngIdBytes)) { 
     return CompressFormat.PNG; 
    } 

    return null; 
} 

Answer 9

if(currentImageType ==null){ 
        ByteArrayInputStream is = new ByteArrayInputStream(image); 
        String mimeType = URLConnection.guessContentTypeFromStream(is); 
        if(mimeType == null){ 
         AutoDetectParser parser = new AutoDetectParser(); 
         Detector detector = parser.getDetector(); 
         Metadata md = new Metadata(); 
         mimeType = detector.detect(is,md).toString(); 

         if (mimeType.contains("pdf")){ 
          mimeType ="pdf"; 
         } 
         else if(mimeType.contains("tif")||mimeType.contains("tiff")){ 
          mimeType = "tif"; 
         } 
        } 
        if(mimeType.contains("png")){ 
         mimeType ="png"; 
        } 
        else if(mimeType.contains("jpg")||mimeType.contains("jpeg")){ 
         mimeType = "jpg"; 
        } 
        else if (mimeType.contains("pdf")){ 
         mimeType ="pdf"; 
        } 
        else if(mimeType.contains("tif")||mimeType.contains("tiff")){ 
         mimeType = "tif"; 
        } 

        currentImageType = ImageType.fromValue(mimeType); 
       }