I have a JPanel to which I ‘d like to add JPEG and PNG images that I produce on the fly.
All the examples I’ve seen up until now in the Swing Tutorials, specifically in the Swing examples use ImageIcons.
I’m creating these images as byte ranges, and they are typically bigger than the common icon they use in the examples, at 640×480.
Exists any (efficiency or other) problem in using the ImageIcon class to display an image that size in a JPanel?
What’s the typical method of doing it?
The best ways to add an image to a JPanel without using the ImageIcon class?
Depending upon how you are generating the byte selections, it might more efficient to utilize a MemoryImageSource than to convert them to JPEG or PNG format and after that read with ImageIO as a lot of answers recommend. You could get an Image from a MemoryImageSource constructed with your image information by utilizing createImage
You can prevent rolling your own Part subclass completely by using the JXImagePanel class from the complimentary SwingX libraries.
There should not be any issue (other than any general problems you might have with huge images).
I would utilize ImageIcons if you’re talking about including multiple images to a single panel. For a single image, I would think of making a custom-made subclass of JPanel and bypassing its paintComponent technique to draw the image.
There is a minor problem with ImageIcon because the builder blocks reading the image. Not really an issue when filling from the application container, but maybe if you’re potentially checking out over a network connection. There’s lots of AWT-era examples of utilizing MediaTracker, ImageObserver and good friends, even in the JDK demonstrations.
byte selections are most likely unefficient unless you can utilize an exact pixel byte buying which matches to your screen adapters current resolution and color depth.
To achieve the best drawing efficiency, just convert your image to a BufferedImage which is produced with a type corresponding to your current graphics setup.
These images will be immediately cached on the screen card memory after drawing a few times with no programs effort (this is standard in Swing considering that Java 6), and therefore the real drawing will take negligible quantity of time – if you did not change the image.
Altering the image will include an additional memory transfer between main memory and GPU memory – which is sluggish. Avoid “redrawing” the image into a BufferedImage for that reason, prevent doing getPixel and setPixel at all ways.
If you are establishing a video game, rather of drawing all the game stars to a BufferedImage and then to a JPanel, it is a lot faster to fill all stars as smaller sized BufferedImages, and draw them one by one in your JPanel code at their appropriate position – this way there is no additional data transfer between the primary memory and GPU memory except of the preliminary transfer of the images for caching.
ImageIcon will utilize a BufferedImage under the hood – but essentially designating a BufferedImage with the correct graphics mode is the key, and there is no effort to do this right.
The typical method of doing this is to draw a BufferedImage in an overridden paintComponent method of the JPanel. Java supports a great quantity of extra goodies such as buffer chains managing VolatileImages cached in the GPU memory, there is no need to utilize any of these because Java 6 which does a fairly excellent task without exposing all of these details of GPU velocity.
“Including” makes sense if the image is part of the design. If you need this as a background or foreground image filling the JPanel, just attract paintComponent. If you choose brewing a generic Swing element which can show your image, then it is the exact same story (you might utilize a JComponent and override its paintComponent method) – then include this to your layout of GUI parts.
Converting your byte selections to PNG, then loading it is quite resource extensive. A better way is to convert your existing byte selection to a BufferedImage.