Bild zuschneiden, um kleinste Größe durch entfernen der transparenten Pixel in java

Habe ich ein sprite-Blatt, das hat jedes Bild zentriert in einem 32x32-Zelle. Die tatsächlichen Bilder sind nicht 32x32, aber etwas kleiner. Was ich gerne tun möchte, ist nehmen Sie eine Zelle aus, und Ernte die transparenten Pixel, sodass das Bild ist so klein wie es nur sein kann.

Wie würde ich das in Java (JDK 6)?

Hier ist ein Beispiel, wie ich bin derzeit brechen der Fliese Blatt in Zellen:

BufferedImage tilesheet = ImageIO.read(getClass().getResourceAsStream("/sheet.png");
for (int i = 0; i < 15; i++) {
  Image img = tilesheet.getSubimage(i * 32, 0, 32, 32);
  //crop here..
}

Meine aktuelle Idee zu testen, wurde jedes pixel von der Mitte der Arbeit meinen Weg, um zu sehen, wenn es transparent ist, aber ich Frage mich, ob es wäre schneller/sauberer Weg, dies zu tun.

InformationsquelleAutor Ruggs | 2010-07-11

2

Ich denke, das ist genau das, was Sie tun sollten, eine Schleife über das array von Pixel check für alpha-und dann verwerfen. Obwohl, wenn Sie, zum Beispiel, hätte einen Stern es wird nicht die Größe des Bildes kleiner werden, bewusst.
- Ja ich bin mir bewusst, dass so etwas wie ein star, nicht der Größenänderung viel. Ich hatte gehofft, es war eine Art eingebauten filter.
InformationsquelleAutor Yonathan

Bild zuschneiden, um kleinste Größe durch entfernen der transparenten Pixel in java

Gibt es eine triviale Lösung – scan jedem pixel. Der Algorithmus, der Balg hat Konstante Leistung O(w•h).

private static BufferedImage trimImage(BufferedImage image) {
    int width = image.getWidth();
    int height = image.getHeight();
    int top = height / 2;
    int bottom = top;
    int left = width / 2 ;
    int right = left;
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < height; y++) {
            if (image.getRGB(x, y) != 0){
                top    = Math.min(top, x);
                bottom = Math.max(bottom, x);
                left   = Math.min(left, x);
                right  = Math.max(right, x);
            }
        }
    }
    return image.getSubimage(left, top, right - left, bottom - top);
}

Aber dies ist viel effektiver:

private static BufferedImage trimImage(BufferedImage image) {
    WritableRaster raster = image.getAlphaRaster();
    int width = raster.getWidth();
    int height = raster.getHeight();
    int left = 0;
    int top = 0;
    int right = width - 1;
    int bottom = height - 1;
    int minRight = width - 1;
    int minBottom = height - 1;

    top:
    for (;top < bottom; top++){
        for (int x = 0; x < width; x++){
            if (raster.getSample(x, top, 0) != 0){
                minRight = x;
                minBottom = top;
                break top;
            }
        }
    }

    left:
    for (;left < minRight; left++){
        for (int y = height - 1; y > top; y--){
            if (raster.getSample(left, y, 0) != 0){
                minBottom = y;
                break left;
            }
        }
    }

    bottom:
    for (;bottom > minBottom; bottom--){
        for (int x = width - 1; x >= left; x--){
            if (raster.getSample(x, bottom, 0) != 0){
                minRight = x;
                break bottom;
            }
        }
    }

    right:
    for (;right > minRight; right--){
        for (int y = bottom; y >= top; y--){
            if (raster.getSample(right, y, 0) != 0){
                break right;
            }
        }
    }

    return image.getSubimage(left, top, right - left + 1, bottom - top + 1);
}

Dieser Algorithmus folgt der Idee von pepan's Antwort (siehe oben) und ist 2 bis 4 mal wirksamer. Der Unterschied ist: es ist nie durchsucht jedes pixel zweimal und versucht zu Vertrag Suchbereich auf jeder Bühne.

Methode, die Leistung im schlimmsten Fall ist O(w•h–a•b)

Das hat mir wirklich geholfen. Ich habe portiert, es auf Android zu arbeiten, mit einem Bitmap mit weißem hintergrund. Ich würde hier posten, wenn jemand interessiert ist.
bitte posten Sie Ihre Lösung, würde ich mag, um es zu überprüfen. Dank

InformationsquelleAutor Oleg Mikhailov

Dieser code funktioniert für mich. Der Algorithmus ist einfach, es geht von Links/oben/rechts/unten im Bild und findet den ersten pixel in der Spalte/Zeile, die ist nicht transparent. Es erinnert sich dann die neue Ecke des beschnittenen Bildes und schließlich gibt es den sub-image of the original image.

Gibt es Dinge, die verbessert werden könnten.

Dem Algorithmus erwartet wird, gibt es die alpha-byte in den Daten. Es wird nicht auf einen index außerhalb der array-Ausnahme, wenn es nicht ist.

Der Algorithmus erwartet, dass es mindestens einen nicht-transparenten pixel im Bild. Es wird scheitern, wenn das Bild komplett transparent ist.

private static BufferedImage trimImage(BufferedImage img) {
final byte[] pixels = ((DataBufferByte) img.getRaster().getDataBuffer()).getData();
int width = img.getWidth();
int height = img.getHeight();
int x0, y0, x1, y1;                      //the new corners of the trimmed image
int i, j;                                //i - horizontal iterator; j - vertical iterator
leftLoop:
for (i = 0; i < width; i++) {
    for (j = 0; j < height; j++) {
        if (pixels[(j*width+i)*4] != 0) { //alpha is the very first byte and then every fourth one
            break leftLoop;
        }
    }
}
x0 = i;
topLoop:
for (j = 0; j < height; j++) {
    for (i = 0; i < width; i++) {
        if (pixels[(j*width+i)*4] != 0) {
            break topLoop;
        }
    }
}
y0 = j;
rightLoop:
for (i = width-1; i >= 0; i--) {
    for (j = 0; j < height; j++) {
        if (pixels[(j*width+i)*4] != 0) {
            break rightLoop;
        }
    }
}
x1 = i+1;
bottomLoop:
for (j = height-1; j >= 0; j--) {
    for (i = 0; i < width; i++) {
        if (pixels[(j*width+i)*4] != 0) {
            break bottomLoop;
        }
    }
}
y1 = j+1;
return img.getSubimage(x0, y0, x1-x0, y1-y0);

}

InformationsquelleAutor pepan

0

Wenn Ihr Blatt schon hat transparente Pixel, die BufferedImage zurückgegeben getSubimage() wird, zu. Die Standard - Graphics2D composite-Regel ist AlphaComposite.SRC_OVER, das sollte reichen für drawImage().

Wenn die sub-Bilder haben eine unterschiedliche Hintergrundfarbe, verwenden Sie eine LookupOp mit einem vier-Komponenten - LookupTable setzt, die die alpha-Komponente zu null für Farben, die mit dem hintergrund.

Ich würde die traverse pixel-raster nur als letzten Ausweg.

Nachtrag: Extra transparente Pixel stören können mit collision detection, etc. Beschneiden Sie benötigen arbeiten mit einem WritableRaster direkt. Anstatt von der Mitte aus, ich würde anfangen mit den Grenzen, mit einem paar von getPixels()/setPixels() Methoden ändern können eine Zeile oder Spalte zu einer Zeit. Wenn eine ganze Zeile oder Spalte, die null-alpha, markieren Sie es für die Beseitigung, wenn du später einen sub-Bild.
- Ich habe derzeit keine Probleme bei der Einstellung der transparenten Pixeln, wie Sie sagte, Einzelbild ist schon zu tun. Was ich will zu tun ist, um clip oder schneiden Sie das Bild so zuschneiden, wie viel von den umliegenden transparente Pixel wie möglich. Meine Zellen sind 32x32, jedoch eine Menge Zeit, das Bild, das ich interessiert bin, nur so etwas wie 14x28.
InformationsquelleAutor trashgod

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.