Java (J2ME) Convertir l'image en octet [], puis revenir à l'image

Question

J'essaie de convertir un objet image en un tableau d'octets, puis de revenir à une image (de sorte que je puisse stocker l'image dans un objet blob dans un Base de données Apache Derby).

Je peux convertir une image en tableau d'octets (code ci-dessous) mais je ne peux pas convertir les octets en une image. Comme une complication supplémentaire j'utilise J2ME, donc je ne peux pas utiliser javax.image. *. Pouvez-vous m'aider?

Merci

package six.util; 
import java.awt.Image; 
import java.awt.image.BufferedImage; 
import java.awt.image.ImageObserver; 
import java.awt.Component; 
import java.awt.MediaTracker; 
import java.awt.Graphics; 
import java.awt.image.DataBufferByte; 
import java.awt.image.WritableRaster; 
import java.awt.GraphicsConfiguration; 
import java.awt.GraphicsDevice; 
import java.awt.GraphicsEnvironment; 
import java.awt.image.PixelGrabber; 
import java.util.ArrayList; 

public class ImageConverter extends Component 
{ 

private MediaTracker mediaTracker; 
private Image image; 

private ImageConverter(Image image) 
{ 
    super(); 
    this.mediaTracker = new MediaTracker(this); 
    this.mediaTracker.addImage(image, 0); 
    this.image = image; 
} 

private BufferedImage convert() 
{ 
    /* 
    * Have to wait for image to load. 
    */ 
    try 
    { 
     this.mediaTracker.waitForID(0); 
    }catch(InterruptedException e) 
    { 

    } 
    System.out.println("-1"); 

    GraphicsConfiguration graphicsConfig = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); 
    BufferedImage bimage = graphicsConfig.createCompatibleImage(this.image.getWidth(null),this.image.getHeight(null)); 
    System.out.println("-2"); 
    Graphics g = bimage.getGraphics(); 
    g.drawImage(image, 0, 0, null); 
    return bimage; 
} 

private static byte[] convertIntToByteArray(int integer) 
{ 
    byte[] bytes = new byte[4]; 
    bytes[0] =(byte)(integer >> 24); 
    bytes[1] =(byte)((integer << 8) >> 24); 
    bytes[2] =(byte)((integer << 16) >> 24); 
    bytes[3] =(byte)((integer << 24) >> 24); 
    return bytes; 
} 

private static int convertByteArrayToInt(byte[] bytes) 
{ 
    return (bytes[0] << 32) | (bytes[1] << 24) | (bytes[2] << 16) | (bytes[3] << 8) | bytes[4]; 
} 

private static byte[] convertIntArrayToByteArray(int[] integers) 
{ 
    byte[] bytes = new byte[integers.length*4]; 
    for (int index = 0; index < integers.length; index++) 
    { 
     byte[] integerBytes = convertIntToByteArray(integers[index]); 
     bytes[index*4] =  integerBytes[0]; 
     bytes[1 + (index*4)] = integerBytes[1]; 
     bytes[2 + (index*4)] = integerBytes[2]; 
     bytes[3 + (index*4)] = integerBytes[3]; 
    } 
    return bytes; 
} 

private static int[] convertByteArrayToIntArray(byte[] bytes) 
{ 
    ArrayList integers = new ArrayList(); 
    for (int index = 0; index < bytes.length; index += 4) 
    { 
     byte[] fourBytes = new byte[4]; 
     fourBytes[0] = bytes[index]; 
     fourBytes[1] = bytes[index+1]; 
     fourBytes[2] = bytes[index+2]; 
     fourBytes[3] = bytes[index+3]; 
     int integer = convertByteArrayToInt(fourBytes); 
     integers.add(new Integer(integer)); 
    } 
    int[] ints = new int[bytes.length/4]; 
    for (int index = 0; index < integers.size() ; index++) 
    { 
     ints[index] = ((Integer)integers.get(index)).intValue(); 
    } 
    return ints; 
} 

public static byte[] convertToBytes(Image image) 
{ 
    System.out.println("A"); 
    ImageConverter converter = new ImageConverter(image); 
    System.out.println("B"); 
    BufferedImage bufferedImage = converter.convert(); 
    System.out.println("C"); 
    PixelGrabber pixelGrabber = new PixelGrabber(image,0,0,bufferedImage.getWidth(),bufferedImage.getHeight(),true); 
    System.out.println("D"); 
    try 
    { 
     if(pixelGrabber.grabPixels()) 
     { 
      Object pixels = pixelGrabber.getPixels(); 
      if (pixels instanceof byte[]) 
      { 
       return (byte[])pixels; 
      } 
      return convertIntArrayToByteArray((int[])pixels); 
     } 
    }catch(InterruptedException e) 
    { 
    } 
    return null; 
} 


} 

Answer 1

Pour recréer l'image que vous pouvez utiliser la méthode createRGBImage dans la classe Image (http://java.sun.com/javame/reference/apis/jsr118/), mais sachez que vous utilisez 4 octets pour chaque pixel dans l'image. Une image avec 200 x 200 pixels de largeur aura 40000 pixels au total, ce qui occupera 160 Ko de mémoire dans l'appareil mobile.

J'ai travaillé avec des images dans J2ME auparavant, mais uniquement en envoyant les images du serveur au client. Dans ce cas, vous pouvez changer la résolution de l'image sur le serveur (où vous avez le code et la puissance brute pour le faire), l'encoder en JPEG et ensuite l'envoyer au client. La méthode Image.createImage (...) peut créer une image dans n'importe quel format encodé supporté par le moteur J2ME qui exécute l'application. Je crois que le JPEG sera toujours accepté.

Même si vous avez besoin de ces images pour une utilisation ultérieure, vous pouvez enregistrer le tampon byte [] renvoyé par le serveur dans un magasin d'enregistrements, puis l'utiliser.

Answer 2

Je ne connais pas javame, mais cela ne fonctionnerait-il pas?

javax.microedition.lcdui.Image.createImage(new ByteArrayInputStream(byte[]))