Schnellste Möglichkeit zum Laden von Thumbnail-Pixelwerten in Java

Question

Ich muss RGB-Pixelwerte mit einer bestimmten Auflösung in Java laden können. Diese Auflösung ist klein (~ 300x300).

Zeit, ich habe sie wie folgt geladen:

File file = new File("...path...");  
BufferedImage imsrc = ImageIO.read(file); 
int width = imsrc.getWidth(); 
int height = imsrc.getHeight();  
int[] data = new int[width * height];  
imsrc.getRGB(0,0, width, height, data, 0, width); 

und dann mich Downsizing.

Sam fragte nach dem Downsizing-Code, so ist es hier:

/** 
* DownSize an image. 
* This is NOT precise, and is noisy. 
* However, this is fast and better than NearestNeighbor 
* @param pixels - _RGB pixel values for the original image 
* @param width - width of the original image 
* @param newWidth - width of the new image 
* @param newHeight - height of the new image 
* @return - _RGB pixel values of the resized image 
*/ 
public static int[] downSize(int[] pixels, int width, int newWidth, int newHeight) { 
    int height = pixels.length/width; 
    if (newWidth == width && height == newHeight) return pixels; 
    int[] resized = new int[newWidth * newHeight]; 
    float x_ratio = (float) width/newWidth; 
    float y_ratio = (float) height/newHeight; 
    float xhr = x_ratio/2; 
    float yhr = y_ratio/2; 
    int i, j, k, l, m; 
    for (int x = 0; x < newWidth; x ++) 
     for (int y = 0; y < newHeight; y ++) {    
      i = (int) (x * x_ratio); 
      j = (int) (y * y_ratio); 
      k = (int) (x * x_ratio + xhr); 
      l = (int) (y * y_ratio + yhr); 
      for (int p = 0; p < 3; p ++) { 
       m = 0xFF << (p * 8); 
       resized[x + y * newWidth] |= (
         (pixels[i + j * width] & m) + 
         (pixels[k + j * width] & m) + 
         (pixels[i + l * width] & m) + 
         (pixels[k + l * width] & m) >> 2) & m; 
      } 
     } 
    return resized; 
} 

Vor kurzem habe ich gemerkt, dass ich kann nach unten Größe mit ImageMagicks ‚umwandeln‘ und laden Sie dann die verkleinerte Version, die Art und Weise . Dies spart zusätzliche 33%.

Ich frage mich, ob es einen noch besseren Weg gibt.

EDIT: Ich erkannte, dass einige Leute sich fragen würden, ob mein Code im Allgemeinen gut ist, und die Antwort ist NEIN. Der Code, den ich verwendet habe, funktioniert gut für mich, weil ich bereits kleine Bilder verkleinere (sagen wir 640x480, ansonsten .getRGB() dauert ewig) und es ist mir egal, wenn ein paar Farbpunkte überlaufen (Verschleppung von Hinzufügung) und ich weiß, dass einige Leute sich wirklich darum kümmern.

Answer 1

Hier ist ein sehr guter Artikel über die Thumbnails in Java in optimaler Weise zu erzeugen:

http://today.java.net/pub/a/today/2007/04/03/perils-of-image-getscaledinstance.html

Sie mit Angabe unterschiedlicher Skalierung bessere Ergebnisse aufweisen kann/Wiedergabeparameter.

Graphics2D g2 = (Graphics2D)g; 
    int newW = (int)(originalImage.getWidth() * xScaleFactor); 
    int newH = (int)(originalImage.getHeight() * yScaleFactor); 
    g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, 
         RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR); 
    g2.drawImage(originalImage, 0, 0, newW, newH, null);