Bagaimana cara menambahkan gambar ke JPanel?

Saya memiliki JPanel yang ingin saya tambahkan gambar JPEG dan PNG yang saya hasilkan dengan cepat.

Semua contoh yang saya lihat sejauh ini dalam Tutorial Swing , khususnya dalam contoh Swing menggunakan ImageIcons.

Saya menghasilkan gambar-gambar ini sebagai array byte, dan mereka biasanya lebih besar dari ikon umum yang mereka gunakan dalam contoh, di 640x480.

1. Apakah ada masalah (kinerja atau lainnya) dalam menggunakan kelas ImageIcon untuk menampilkan gambar sebesar JPanel?
2. Apa cara yang biasa dilakukan?
3. Bagaimana cara menambahkan gambar ke JPanel tanpa menggunakan kelas ImageIcon?

Sunting : Pemeriksaan tutorial dan API yang lebih cermat menunjukkan bahwa Anda tidak dapat menambahkan ImageIcon langsung ke JPanel. Sebaliknya, mereka mencapai efek yang sama dengan mengatur gambar sebagai ikon JLabel. Rasanya tidak benar ...

Inilah cara saya melakukannya (dengan sedikit info lebih lanjut tentang cara memuat gambar):

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.JPanel;

public class ImagePanel extends JPanel{

    private BufferedImage image;

    public ImagePanel() {
       try {                
          image = ImageIO.read(new File("image name and path"));
       } catch (IOException ex) {
            // handle exception...
       }
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawImage(image, 0, 0, this); // see javadoc for more info on the parameters            
    }

}

Jika Anda menggunakan JPanels, maka mungkin bekerja dengan Swing. Coba ini:

BufferedImage myPicture = ImageIO.read(new File("path-to-file"));
JLabel picLabel = new JLabel(new ImageIcon(myPicture));
add(picLabel);

Gambar sekarang merupakan komponen ayun. Itu menjadi tunduk pada kondisi tata letak seperti komponen lainnya.

Cara Fred Haslam bekerja dengan baik. Saya mengalami masalah dengan filepath, karena saya ingin referensi gambar dalam toples saya. Untuk melakukan ini, saya menggunakan:

BufferedImage wPic = ImageIO.read(this.getClass().getResource("snow.png"));
JLabel wIcon = new JLabel(new ImageIcon(wPic));

Karena saya hanya memiliki jumlah gambar terbatas (sekitar 10) yang saya perlu memuat menggunakan metode ini, itu bekerja dengan cukup baik. Ia mendapat file tanpa harus memiliki relatif relatif file yang benar.

Saya pikir tidak perlu subkelas apa pun. Cukup gunakan Jlabel. Anda dapat mengatur gambar menjadi Jlabel. Jadi, ubah ukuran Jlabel lalu isi dengan gambar. Tidak apa-apa. Inilah yang saya lakukan.

Anda dapat menghindari menggulirkan subkelas Komponen Anda sepenuhnya dengan menggunakan kelas JXImagePanel dari SwingX gratis pustaka .

Unduh

JLabel imgLabel = new JLabel(new ImageIcon("path_to_image.png"));

Anda dapat mensubklasifikasikan JPanel - ini adalah ekstrak dari ImagePanel saya, yang menempatkan gambar di salah satu dari 5 lokasi, atas / kiri, atas / kanan, tengah / tengah, bawah / kiri atau bawah / kanan:

protected void paintComponent(Graphics gc) {
    super.paintComponent(gc);

    Dimension                           cs=getSize();                           // component size

    gc=gc.create();
    gc.clipRect(insets.left,insets.top,(cs.width-insets.left-insets.right),(cs.height-insets.top-insets.bottom));
    if(mmImage!=null) { gc.drawImage(mmImage,(((cs.width-mmSize.width)/2)       +mmHrzShift),(((cs.height-mmSize.height)/2)        +mmVrtShift),null); }
    if(tlImage!=null) { gc.drawImage(tlImage,(insets.left                       +tlHrzShift),(insets.top                           +tlVrtShift),null); }
    if(trImage!=null) { gc.drawImage(trImage,(cs.width-insets.right-trSize.width+trHrzShift),(insets.top                           +trVrtShift),null); }
    if(blImage!=null) { gc.drawImage(blImage,(insets.left                       +blHrzShift),(cs.height-insets.bottom-blSize.height+blVrtShift),null); }
    if(brImage!=null) { gc.drawImage(brImage,(cs.width-insets.right-brSize.width+brHrzShift),(cs.height-insets.bottom-brSize.height+brVrtShift),null); }
    }

1. Seharusnya tidak ada masalah (selain masalah umum yang Anda miliki dengan gambar yang sangat besar).
2. Jika Anda berbicara tentang menambahkan banyak gambar ke satu panel, saya akan menggunakan ImageIcons. Untuk satu gambar, saya akan berpikir tentang membuat subkelas kustom JPaneldan mengganti paintComponentmetodenya untuk menggambar.
3. (lihat 2)

JPanelhampir selalu kelas yang salah untuk subkelas. Mengapa Anda tidak akan subkelasJComponent ?

Ada sedikit masalah dengan ImageIconkonstruktor yang memblokir membaca gambar. Tidak terlalu masalah saat memuat dari toples aplikasi, tetapi mungkin jika Anda berpotensi membaca melalui koneksi jaringan. Ada banyak contoh era AWT untuk menggunakan MediaTracker, ImageObserverdan teman-teman, bahkan dalam demo JDK.

Saya melakukan sesuatu yang sangat mirip dalam proyek pribadi yang sedang saya kerjakan. Sejauh ini saya telah menghasilkan gambar hingga 1024x1024 tanpa masalah (kecuali memori) dan dapat menampilkannya dengan sangat cepat dan tanpa masalah kinerja.

Mengganti metode cat subclass JPanel adalah berlebihan dan membutuhkan lebih banyak pekerjaan daripada yang harus Anda lakukan.

Cara saya melakukannya adalah:

Class MapIcon implements Icon {...}

ATAU

Class MapIcon extends ImageIcon {...}

Kode yang Anda gunakan untuk menghasilkan gambar akan berada di kelas ini. Saya menggunakan BufferedImage untuk menarik ketika paintIcon () dipanggil, gunakan g.drawImvge (bufferedImage); Ini mengurangi jumlah flashing yang dilakukan saat Anda menghasilkan gambar, dan Anda dapat mengaitkannya.

Berikutnya saya memperpanjang JLabel:

Class MapLabel extends Scrollable, MouseMotionListener {...}

Ini karena saya ingin meletakkan gambar saya pada panel gulir, yaitu menampilkan bagian dari gambar dan meminta pengguna untuk menggulirkan sesuai kebutuhan.

Jadi saya menggunakan JScrollPane untuk memegang MapLabel, yang hanya berisi MapIcon.

MapIcon map = new MapIcon (); 
MapLabel mapLabel = new MapLabel (map);
JScrollPane scrollPane = new JScrollPane();

scrollPane.getViewport ().add (mapLabel);

Tapi untuk skenario Anda (hanya perlihatkan seluruh gambar setiap waktu). Anda perlu menambahkan MapLabel ke JPanel atas, dan pastikan untuk mengukur semuanya ke ukuran penuh gambar (dengan menimpa GetPreferredSize ()).

Buat folder sumber di direktori proyek Anda, dalam hal ini saya menyebutnya Gambar.

JFrame snakeFrame = new JFrame();
snakeFrame.setBounds(100, 200, 800, 800);
snakeFrame.setVisible(true);
snakeFrame.add(new JLabel(new ImageIcon("Images/Snake.png")));
snakeFrame.pack();

Anda dapat menghindari menggunakan Componentperpustakaan dan ImageIOkelas milik sendiri dan SwingX :

File f = new File("hello.jpg");
JLabel imgLabel = new JLabel(new ImageIcon(file.getName()));

Jawaban ini adalah pelengkap dari jawaban @ shawalli ...

Saya ingin referensi gambar di dalam toples saya juga, tetapi alih-alih memiliki BufferedImage, saya sederhana melakukan ini:

 JPanel jPanel = new JPanel();      
 jPanel.add(new JLabel(new ImageIcon(getClass().getClassLoader().getResource("resource/images/polygon.jpg"))));

Saya bisa melihat banyak jawaban, tidak benar-benar menjawab tiga pertanyaan OP.

1) Sebuah kata pada kinerja: array byte cenderung tidak efisien kecuali jika Anda dapat menggunakan pemesanan byte pixel yang tepat yang cocok dengan display adapter Anda resolusi saat ini dan kedalaman warna.

Untuk mencapai kinerja gambar terbaik, cukup konversikan gambar Anda ke BufferedImage yang dihasilkan dengan jenis yang sesuai dengan konfigurasi grafis Anda saat ini. Lihat createCompatibleImage di https://docs.oracle.com/javase/tutorial/2d/images/drawonimage.html

Gambar-gambar ini akan secara otomatis di-cache pada memori kartu tampilan setelah menggambar beberapa kali tanpa upaya pemrograman (ini adalah standar dalam Swing sejak Java 6), dan oleh karena itu gambar yang sebenarnya akan memakan waktu yang dapat diabaikan - jika Anda tidak mengubah gambar .

Mengubah gambar akan disertai dengan transfer memori tambahan antara memori utama dan memori GPU - yang lambat. Hindari "menggambar ulang" gambar menjadi BufferedImage karena itu, hindari melakukan getPixel dan setPixel dengan segala cara.

Misalnya, jika Anda mengembangkan game, alih-alih menarik semua aktor game ke BufferedImage dan kemudian ke JPanel, jauh lebih cepat untuk memuat semua aktor sebagai BufferedImages yang lebih kecil, dan menggambar mereka satu per satu dalam kode JPanel Anda di posisi yang tepat - dengan cara ini tidak ada transfer data tambahan antara memori utama dan memori GPU kecuali transfer awal gambar untuk caching.

ImageIcon akan menggunakan BufferedImage di bawah tenda - tetapi pada dasarnya mengalokasikan BufferedImage dengan mode grafis yang tepat adalah kuncinya, dan tidak ada upaya untuk melakukan ini dengan benar.

2) Cara yang biasa dilakukan adalah dengan menggambar BufferedImage dalam metode paintComponent dari JPanel yang diganti. Meskipun Java mendukung sejumlah barang tambahan yang bagus seperti rantai penyangga yang mengendalikan VolatileImages yang di-cache dalam memori GPU, tidak perlu menggunakan semua ini karena Java 6 yang melakukan pekerjaan yang cukup baik tanpa memaparkan semua detail akselerasi GPU ini.

Perhatikan bahwa akselerasi GPU mungkin tidak berfungsi untuk operasi tertentu, seperti peregangan gambar yang tembus cahaya.

3) Jangan menambahkan. Cukup cat seperti yang disebutkan di atas:

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    g.drawImage(image, 0, 0, this); 
}

"Menambahkan" masuk akal jika gambar merupakan bagian dari tata letak. Jika Anda membutuhkan ini sebagai gambar latar atau latar depan yang mengisi JPanel, cukup menggambar paintComponent. Jika Anda lebih suka membuat komponen Swing umum yang dapat menampilkan gambar Anda, maka itu adalah cerita yang sama (Anda dapat menggunakan JComponent dan mengganti metode paintComponentnya) - dan kemudian menambahkan ini ke tata letak komponen GUI Anda.

4) Cara mengonversi array menjadi Bufferedimage

Mengubah byte array Anda ke PNG, kemudian memuatnya cukup banyak sumber daya. Cara yang lebih baik adalah mengonversi array byte yang ada ke BufferedImage.

Untuk itu: jangan gunakan untuk loop dan menyalin piksel. Itu sangat lambat. Sebagai gantinya:

• mempelajari struktur byte yang disukai dari BufferedImage (saat ini aman untuk menganggap RGB atau RGBA, yaitu 4 byte per piksel)
• pelajari garis pemindaian dan scansize yang digunakan (mis. Anda mungkin memiliki gambar lebar 142 piksel - tetapi dalam kehidupan nyata itu akan disimpan sebagai array byte lebar 256 piksel karena lebih cepat memprosesnya dan menutupi piksel yang tidak digunakan oleh perangkat keras GPU )
• kemudian setelah Anda memiliki array array sesuai dengan prinsip-prinsip ini, metode array setRGB dari BufferedImage dapat menyalin array Anda ke BufferedImage.