Convert Picture to Bytes & Get Image Size in Java

To convert a picture into bytes and get its width and height in Java, you read the image file into a byte array and then use ImageIO.read() to obtain a BufferedImage, from which you call getWidth() and getHeight(). This works for common formats like JPEG, PNG, GIF, and BMP, and the byte array is useful for database storage, network transfer, or encryption.

Formula

The conversion from an image file to bytes does not follow a single mathematical formula; it depends on the image’s encoding (JPEG, PNG, etc.) and its internal compression. However, the relationship between dimensions and file size for an uncompressed bitmap is:

File Size (bytes) ≈ width × height × bytesPerPixel

Where width and height are in pixels, and bytesPerPixel is typically 3 for RGB (24-bit) or 4 for ARGB (32-bit) images. For compressed formats, the actual size varies based on content and compression settings, so this formula serves only as an upper bound estimate.

Worked Example

Suppose you have a 24-bit BMP image that is 100 pixels wide and 50 pixels high. Using the formula:

1. Bytes per pixel = 3 (24 bits / 8 bits per byte)
2. Total bytes = 100 × 50 × 3 = 15,000 bytes
3. Add header bytes (typically 54 for BMP) → 15,054 bytes

In Java, if you load this image and convert it to a byte array, the array length will be close to 15,054 bytes (the exact value depends on row padding). For JPEG or PNG, the compressed size will be much smaller, often 5–20% of the uncompressed size.

Why Convert an Image to Bytes?

Storing an image as a byte array is common in several real-world scenarios:

• Database storage: BLOB (Binary Large Object) columns accept byte arrays directly.
• Network transmission: Sending an image over a socket or REST API often requires bytes.
• Encryption: Encrypting an image requires operating on its raw bytes.
• In-memory processing: Some libraries (e.g., image scaling) accept byte arrays as input.

Getting the width and height is usually needed to display the image correctly or to validate that the byte data represents a valid image before further processing.

How to Read Image Dimensions from a Byte Array

If you already have a byte array (e.g., from a database), you can create a ByteArrayInputStream and pass it to ImageIO.read(). Here is a complete method:

public static int[] getImageSize(byte[] imageBytes) throws IOException {
    try (ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes)) {
        BufferedImage img = ImageIO.read(bais);
        if (img == null) {
            throw new IOException("Unsupported image format");
        }
        return new int[]{img.getWidth(), img.getHeight()};
    }
}

This method returns an array with width at index 0 and height at index 1. If the byte array does not contain a supported image, ImageIO.read() returns null, so you must check for that to avoid a NullPointerException.

How to Convert an Image File to a Byte Array

To read a file from disk into a byte array, use Files.readAllBytes() (Java 7+) or the older FileInputStream. Then you can get dimensions using the method above. Example:

Path path = Paths.get("example.jpg");
byte[] bytes = Files.readAllBytes(path);
int[] size = getImageSize(bytes);
System.out.println("Width: " + size[0] + ", Height: " + size[1]);

If you need to convert a BufferedImage (e.g., after modifying it) back to bytes, use ImageIO.write() with a ByteArrayOutputStream:

ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(bufferedImage, "png", baos);
byte[] bytes = baos.toByteArray();

Note that the format string (“png”, “jpg”) must be supported by the installed ImageIO plugins; JPEG does not support transparency, so converting an ARGB image to JPEG will lose the alpha channel.

Common Problems and How to Avoid Them

• OutOfMemoryError: Reading a very large image into a byte array consumes a lot of memory. For a 4000×3000 24-bit image, the byte array is about 36 MB (uncompressed), but the BufferedImage may take more. Use ImageIO.createImageInputStream() with streaming if memory is a concern.
• Unsupported format: ImageIO.read() returns null for formats like SVG (vector) or WebP (unless a plugin is added). Check the return value.
• Corrupted data: If the byte array is truncated or corrupted, ImageIO.read() may throw an IOException or return null. Wrap the call in a try-catch.
• Different color models: getWidth() and getHeight() return the pixel dimensions, not the DPI. If you need physical size, you must read the metadata separately.

Alternatives to ImageIO

While ImageIO is the standard Java approach, it has limitations (e.g., no built-in WebP support). Alternatives include:

• TwelveMonkeys: A plugin library that extends ImageIO to support formats like WebP, TIFF, and SVG.
• Apache Commons Imaging: A pure-Java library for reading image metadata and pixel data, useful for formats ImageIO cannot handle.
• BufferedImage.getRGB(): If you need pixel-level access, you can use getRGB() on the BufferedImage, but this is slower than direct byte manipulation.

For simply reading dimensions without loading the full image, you can parse the image header manually (e.g., PNG stores width and height in the first 24 bytes), which is much faster for large images. However, this requires format-specific code and is more error-prone.

Frequently Asked Questions

How do I convert a byte array back to an image file?

Use Files.write(Path.of("output.png"), bytes) to write the byte array directly to a file. Make sure the extension matches the actual format of the bytes; if you are unsure, you can use ImageIO.write() to a ByteArrayOutputStream with a known format.

Why does ImageIO.read() return null for my byte array?

This happens when the byte array does not contain a valid image format that ImageIO recognizes. Common causes: the file is not an image (e.g., a text file), the format is not supported (like WebP without a plugin), or the data is corrupted. Check the first few bytes for a known magic number (e.g., PNG starts with 0x89 0x50 0x4E 0x47).

Can I get image dimensions without loading the entire byte array into memory?

Yes, you can read only the header of the file. For PNG, the width and height are at bytes 16–23; for JPEG, you must parse the SOF marker. Using ImageIO.createImageInputStream() with ImageReader allows you to read dimensions without decoding the full image, which is more memory-efficient.

Is there a difference between getWidth() and getWidth(null)?

In BufferedImage, getWidth() takes no arguments and returns the width in pixels. getWidth(ImageObserver) is inherited from Image and is used for asynchronous loading; it returns -1 if the width is not yet known. For BufferedImage, the width is always known, so both return the same value, but using getWidth() is clearer.

What is the best way to store an image in a database?

Convert the image to a byte array and store it in a BLOB column. For large images, consider compressing them first (e.g., to JPEG with a quality setting) to reduce storage and transfer time. Always retrieve the bytes and validate them with ImageIO.read() before displaying.

Does the byte array size equal the file size on disk?

Yes, if you read the file with Files.readAllBytes(), the byte array length equals the file size in bytes. However, when you convert a BufferedImage to bytes using ImageIO.write(), the resulting byte array may differ from the original file size because re-encoding can change compression.

Related

• Easiest Way to Change Text Font Size on iPhone
• Writer’s Block vs Procrastination: Key Differences
• Fish It Admin Abuse Times? Facts & Context

in t | Finish time | min | 50 | 0
in d | Distance | km | 10 | 0
out pace | Average pace | min/km | t / d | 2
out speed | Average speed | km/h | d / (t / 60) | 2