Cómo utilizar ImageObserver en el método de Gráficos drawImage()

Question

El método que estoy tratando de usar es el método drawImage (imagen, int, int, int, ImageObserver) para poder escalar mi imagen, en todos los ejemplos que he visto en ImageObserver deberían ser esto, pero esto no parece funcionar (es decir, los únicos métodos que he visto son: drawImage (image, int, int, ImageObserver), no sé si esto hace diferencia).

Aquí es mi clase principal que es el applet:

import java.applet.*; 
import java.awt.*; 

public class Main extends Applet implements Runnable{ 
    private Thread th; 
    private Hitter hitter; 

    //double buffering 
    private Graphics dbg; 
    private Image dbImage; 

    public void init(){ 
     hitter = new Hitter(getImage(getCodeBase(), "Chitter.png")); 
    } 

    public void start(){ 
     th = new Thread(this); 
     th.start(); 
    } 

    public void stop(){ 
     th.stop(); 
    } 

    public void update(Graphics g){ 
     if(dbImage == null){ 
      dbImage = createImage(this.getSize().width, this.getSize().width); 
      dbg = dbImage.getGraphics(); 
     } 

     dbg.setColor(getBackground()); 
     dbg.fillRect(0, 0, this.getSize().width, this.getSize().height); 
     dbg.setColor(getForeground()); 
     paint(dbg); 

     g.drawImage(dbImage, 0, 0, this); 
    } 

    public void paint(Graphics g){ 
     hitter.drawHitter(g); 
    } 

    public void run() { 
     Thread.currentThread().setPriority(Thread.MIN_PRIORITY); 
     while(true){ 
      repaint(); 

      try{ 
       Thread.sleep(15); 
      }catch(InterruptedException ex){} 

      Thread.currentThread().setPriority(Thread.MAX_PRIORITY); 
     } 
    } 

    public boolean mouseMove(Event e, int x, int y){ 
     hitter.move(x); 

     return true; 
    } 

} 

Aquí es la clase de bateador:

import java.awt.*; 
import java.awt.image.ImageObserver; 

public class Hitter{ 
    private int x, y; 
    private Image hitter; 
    private int hitterWidth = 50, hitterHeight = 10; 
    private int appletsizeX = 500, appletsizeY = 500; 

    Hitter(Image i){ 
     hitter = i; 
     start(); 
    } 

    public void drawHitter(Graphics g){ 
     g.drawImage(hitter, x, y, hitterWidth, hitterHeight, this); 
    } 

    public void move(int a){ 
     x = a; 
    } 

    public void start(){ 
     x = appletsizeX/2 - hitterWidth/2; 
     y = 0; 
    } 
} 

Answer 1

A menos que la clase en la que está llamando Graphics.drawImage(Image, int, int, int, int, ImageObserver) es un ImageObserver, utilizando this como el argumento para el ImageObserver no funcionará:

class MyClass { 
    public void resizeImage() { 
    Graphics g = getGraphicsObjectFromSomewhere(); 

    // The following line will not compile, as `MyClass` 
    // does not implement `ImageObserver`. 
    g.drawImage(img, 0, 0, 50, 50, this); 
    } 
} 

Si va a cambiar el tamaño de una imagen que no requiere una ImageObserver (como un BufferedImage que ya contiene la imagen que desea cambiar de tamaño), entonces usted puede simplemente entregar una null:

// The image we want to resize 
BufferedImage img = ImageIO.read("some-image.jpg"); 

// The Graphics object of the destination 
// -- this will probably just be obtained from the destination image. 
Graphics g = getGraphicsObjectFromSomewhere(); 

// Perform the resizing. Hand a `null` for the ImageObserver, 
// as we don't need one. 
g.drawImage(img, 0, 0, 50, 50, null); 

Dicho esto, Voy a agregar un pequeño conector para la biblioteca de cambio de tamaño de mi imagen Thumbnailator.

Si todo lo que se requiere es cambiar el tamaño de una imagen, se puede llevar a cabo tan simple como el siguiente código:

Thumbnails.of("path/to/image") 
    .size(100, 100) 
    .toFile("path/to/thumbnail"); 

Thumbnailator es lo suficientemente flexible como para aceptar BufferedImage s, File s, y InputStream s como entrada .

---

Al ver tu edición, sugeriría cambiar la clase Hitter, por lo que va a realizar el cambio de tamaño de la imagen en el constructor.

Desde que está llamando el método drawHitter en cada llamada de la Applet.drawImage, la operación de cambio de tamaño utilizando Graphics.drawImage está siendo llamado muchas veces, incluso cuando el hitterWidth y hitterHeight son, para todos los efectos, constantes.

Cambiando el tamaño del Image antes de tiempo, y dibujando esa imagen pre-redimensionada en el método drawHitter será más eficiente.