Loading an Image in pieces

Question

Suppose I have an image that I want to modify in some way using a Java application. Suppose this image is over 6 gigabytes in size, and thus I would not want to load it all into memory at once (or, even more likely, I don't actually have that much memory [in fact, I don't think the Java heapspace would even allow such a thing to begin with]).
The obvious solution would be to load a piece of it (256x256, or 512x512, or something similar), process that piece, write that piece out to a file, rinse, repeat, until I'm done.
Here is the problem: I have absolutely no idea how to do the "loading just a piece" part. If my goal were to scale the image and display it, I would have Image.getScaledInstance(), which people claim automagically does the thing I'm describing for scaling. But that's not my goal.
I've searched quite a bit on these forums, but all I ever come up with are posts about TIFF tiles, or posts outlining how you would 1.) load the entire image into memory and 2.) then cut it into subimages, which kind of defeats the purpose.
As I have been thinking about the problem while writing this, the best idea I can come up with would be to treat the image like a standard file, open a stream to it, and then read the data section by section into a byte array or arrays. But then I wouldn't be able to use stuff like BufferedImage.getRGB() for processing pixels. Not to mention the fact that all hell would probably break loose when it would try to apply the image processing to the first section of data, which would contain image headers.
Any ideas or links to ideas would be helpful. Thanks.

Answer 1

Maxideon wrote:
Then treat the 6 GB image file as an ordinary file and copy it using standard IO (or NIO) and then change the pixels of the new file using the methods I mentioned.This makes sense, and would be trivial to pull off. But in many cases I would want to process only a fraction of the original image, thus resulting in lots of extraneous image data in the output image if I just copied the image over wholesale and then applied the processing to a specific block of it.
Say I only want to process the left 50% of my source image, thus resulting in a destination image that is half the dimensions of my source image (Ex. 80,000x35,000 --> 40,000x35,000). The left 50% of my source image would be ~3GB, which is still far too large of an image to load entirely into memory. Which is exactly what I would have to do if I used, say, ImageIO.write(), because all three flavors of that method require as their first parameter an object that implements the RenderedImage interface (I.e. a BufferedImage, because that's the only standard class that does), and while testing instantiating a BufferedImage object with possible width and height values in the tens of thousands (which is obviously quite possible), it throws a NegativeArraySizeException. Which is itself a moot point, because even if that wasn't happening, I still couldn't fill it with real-world image data due to the data's sheer size.
Since I can easily determine what size the output image is going to end up being (and, in fact, am already doing so in the code), the optimal solution would be to create an image file of the correct dimensions and then fill it with white/black/whatever pixels. The problem now is that I have no idea how to do that without having to first build the image in memory, which is much like my original problem except on the other end.
Thanks to this thread, I now know how to load a giant image in smaller blocks, as well as how to then save these blocks to a pre-existing destination image file. I just can't figure out how to create that destination image file with the proper dimensions so that it is actually "pre-existing." Or, conversely, build up the destination image file block by block, as I process each block and am ready to write them out to their destination.
A.) I don't want to just overwrite my source image.
B.) My destination image is not necessarily the same size as my source image.