Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
* The optional {@code BufferedImage} parameter may be reused to store
* the copy of the pixels.
* A new {@code BufferedImage} will be created if the supplied object
* is null, is too small or of a type which the image pixels cannot
* be easily converted into.
*
* @param img the JavaFX {@code Image} to be converted
* @param bimg an optional {@code BufferedImage} object that may be
* used to store the returned pixel data
* @return a {@code BufferedImage} containing a snapshot of the JavaFX
* {@code Image}, or null if the {@code Image} is not readable.
*/
public static @Nullable BufferedImage fromFXImage(Image img, @Nullable BufferedImage bimg) {
// This method has been copied from class SwingFXUtils.
PixelReader pr = img.getPixelReader();
if (pr == null) {
return null;
}
int iw = (int) img.getWidth();
int ih = (int) img.getHeight();
PixelFormat fxFormat = pr.getPixelFormat();
boolean srcPixelsAreOpaque = isSrcPixelsAreOpaque(bimg, pr, iw, ih, fxFormat);
int prefBimgType = getBestBufferedImageType(pr.getPixelFormat(), bimg, srcPixelsAreOpaque);
if (bimg != null) {
int bw = bimg.getWidth();
int bh = bimg.getHeight();
if (bw < iw || bh < ih || bimg.getType() != prefBimgType) {
bimg = null;
} else if (iw < bw || ih < bh) {
Graphics2D g2d = bimg.createGraphics();
g2d.setComposite(AlphaComposite.Clear);
g2d.fillRect(0, 0, bw, bh);
g2d.dispose();
}
}
if (bimg == null) {
bimg = new BufferedImage(iw, ih, prefBimgType);
}
DataBufferInt db = (DataBufferInt) bimg.getRaster().getDataBuffer();
int[] data = db.getData();
int offset = bimg.getRaster().getDataBuffer().getOffset();
int scan = 0;
SampleModel sm = bimg.getRaster().getSampleModel();
if (sm instanceof SinglePixelPackedSampleModel) {
scan = ((SinglePixelPackedSampleModel) sm).getScanlineStride();
}
WritablePixelFormat pf = getAssociatedPixelFormat(bimg);
pr.getPixels(0, 0, iw, ih, pf, data, offset, scan);
return bimg;
}
private static boolean isSrcPixelsAreOpaque(BufferedImage bimg, PixelReader pr, int iw, int ih, PixelFormat fxFormat) {
boolean srcPixelsAreOpaque = false;
switch (fxFormat.getType()) {
case INT_ARGB_PRE:
case INT_ARGB:
case BYTE_BGRA_PRE:
case BYTE_BGRA:
// Check fx image opacity only if
// supplied BufferedImage is without alpha channel
if (bimg != null &&
(bimg.getType() == BufferedImage.TYPE_INT_BGR ||
bimg.getType() == BufferedImage.TYPE_INT_RGB)) {
srcPixelsAreOpaque = checkFXImageOpaque(pr, iw, ih);
}
break;
case BYTE_RGB:
srcPixelsAreOpaque = true;
break;
}
return srcPixelsAreOpaque;
}
//
private static boolean checkFXImageOpaque(PixelReader pr, int iw, int ih) {
for (int y = 0; y < ih; y++) {
for (int x = 0; x < iw; x++) {
int argb = pr.getArgb(x, y);
if ((argb & 0xff000000) != 0xff000000) {
return false;
}
}
}
return true;
}
/**
* Determine the optimal BufferedImage type to use for the specified
* {@code fxFormat} allowing for the specified {@code bimg} to be used
* as a potential default storage space if it is not null and is compatible.
*
* @param fxFormat the PixelFormat of the source FX Image
* @param bimg an optional existing {@code BufferedImage} to be used
* for storage if it is compatible, or null
* @return the best image type
*/
static int getBestBufferedImageType(PixelFormat fxFormat,
@Nullable BufferedImage bimg,
boolean isOpaque) {
// This method has been copied from class SwingFXUtils.
if (bimg != null) {
int bimgType = bimg.getType();
if (bimgType == BufferedImage.TYPE_INT_ARGB ||
bimgType == BufferedImage.TYPE_INT_ARGB_PRE ||
(isOpaque &&
(bimgType == BufferedImage.TYPE_INT_BGR ||
bimgType == BufferedImage.TYPE_INT_RGB))) {
// We will allow the caller to give us a BufferedImage
// that has an alpha channel, but we might not otherwise
// construct one ourselves.
// We will also allow them to choose their own premultiply
// type which may not match the image.
// If left to our own devices we might choose a more specific
// format as indicated by the choices below.
return bimgType;
}
}
return switch (fxFormat.getType()) {
default -> BufferedImage.TYPE_INT_ARGB_PRE;
case BYTE_BGRA, INT_ARGB -> BufferedImage.TYPE_INT_ARGB;
case BYTE_RGB -> BufferedImage.TYPE_INT_RGB;
case BYTE_INDEXED -> (fxFormat.isPremultiplied()
? BufferedImage.TYPE_INT_ARGB_PRE
: BufferedImage.TYPE_INT_ARGB);
};
}
/**
* Determine the appropriate {@link WritablePixelFormat} type that can
* be used to transfer data into the indicated BufferedImage.
*
* @param bimg the BufferedImage that will be used as a destination for
* a {@code PixelReader#getPixels()} operation.
* @return the pixel format
*/
private static WritablePixelFormat
getAssociatedPixelFormat(BufferedImage bimg) {
// This method has been copied from class SwingFXUtils.
// Should not happen...
return switch (bimg.getType()) {
// We lie here for xRGB, but we vetted that the src data was opaque
// so we can ignore the alpha. We use ArgbPre instead of Argb
// just to get a loop that does not have divides in it if the
// PixelReader happens to not know the data is opaque.
case BufferedImage.TYPE_INT_RGB, BufferedImage.TYPE_INT_ARGB_PRE -> PixelFormat.getIntArgbPreInstance();
case BufferedImage.TYPE_INT_ARGB -> PixelFormat.getIntArgbInstance();
default -> throw new InternalError("Failed to validate BufferedImage type");
};
}
}
