Java (J2ME) Convert Bild [] auf Byte, dann zurück zum Bild

Question

Ich versuche, ein Image-Objekt in ein Bytearray konvertieren dann zurück in ein Bild (so, dass ich das Bild in einem Blob-Objekt in einer Apache Derby Datenbank speichern kann).

kann ich ein Bild in einen Byte-Array (Code unten) konvertieren, aber ich cann't die Bytes wieder in ein Bild konvertieren. Als weitere Komplikation J2ME Ich verwende, so kann ich nicht javax.image verwenden. *. Kannst du helfen?

Danke

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

Um das Bild erstellen Sie die Methode createRGBImage in der Image-Klasse verwenden können ( http : //java.sun.com/javame/reference/apis/jsr118/ ), aber bewusst sein, dass Sie auf dem Bild für jedes Pixel 4 Bytes verwenden. Ein Bild mit 200 x 200 Pixeln Breite 40000 Pixel insgesamt haben wird, die 160 KB von Speicher in der mobilen Vorrichtung einnehmen wird.

Ich habe vor mit Bildern in J2ME gearbeitet, aber nur die Bilder vom Server an den Client gesendet. In diesem Fall können Sie die Auflösung des Bildes auf dem Server ändern (wo Sie den Code und die rohe Kraft haben zu tun), kodieren sie als JPEG und es dann an den Client senden. Das Verfahren Image.createImage (...) kann ein Bild in jedem codierten Format von dem J2ME Motor unterstützt schaffen, der die Anwendung ausgeführt wird. Ich glaube, dass JPEG wird immer akzeptiert werden.

Auch wenn Sie diese Bilder für den zukünftigen Gebrauch benötigen, können Sie das Byte speichern [] vom Server in einem Record Store zurück Puffer und dann verwenden.

Answer 2

Ich weiß nicht, über JavaME, aber würde das nicht?

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