CODEWITHSUNDEEP
javaimageimage-processing
Alex I
Alex I

Reputation: 20287

Images in java: most efficient float representation?

I need to do some image manipulation in java. I am porting python code, which uses numpy arrays with dimensions cols, rows, channels; these are floating point. I know how to get RGB out of a BufferedImage and how to put it back; this question is about how to lay out the resulting float image.

Here are some of the options:

  1. direct translation:
float[][][] img = new float[cols][rows][channels];
  1. put channels first:
float[][][] img = new float[channels][cols][rows];
  1. combine indexes:
float[] img = new float[rows*cols*channels];
img[ i * cols * channels + j * channels + k ] = ...;

Option 1 has the advantage that it reads the same as the original code; but it seems non-idiomatic for Java, and probably not fast.

Option 2 should be faster, if I understand how Java N-dimensional arrays work under the hood; at the cost of looking slightly odd. It seems this allocates channels*cols arrays of size rows, as opposed to option 1 which allocates rows*cols arrays of size channels (a very large number of tiny arrays = large overhead).

Option 3 seems to be closest to what the AWT and other Java code does; but it requires passing around the dimensions (they are not built into the array) and it is very easy to get the indexing wrong (especially when there is other index arithmetic going on).

Which of these is better and why? What are some of the other pros and cons? Is there an even better way?

UPDATE

I benchmarked options 1 and 2, on a non-trivial example of image processing which runs four different algorithms (in a 10x loop, so the VM gets to warm up). This is on OpenJDK 7 on Ubuntu, Intel i5 cpu. Surprisingly, there isn't much of a speed difference: option 2 is about 6% slower than option 1. There is a pretty large difference in amount of memory garbage-collected (using java -verbose:gc): option 1 collects 1.32 GB of memory during the entire run, while option 2 collects only 0.87 GB (not quite half, but then again not all images used are color). I wonder how much difference there will be in Dalvik?

Upvotes: 1

Views: 759

Answers (3)

JHead
JHead

Reputation: 426

BoofCV has float image types and the raw pixel data can manipulated directly. See the tutorial.

BoofCV provides several routines for quickly converting BufferedImage into different BoofCV image types. Using BoofCV routines for converting to/from BufferedImages are very fast.

Convert a BufferedImage to a multispectral float type image with BoofCV: 

MultiSpectral<ImageFloat32> image =
    ConvertBufferedImage.convertFromMulti(image,null,true,ImageFloat32.class);

Access pixel value from the float image array:

float value = image.getBand(i).data[ image.startIndex + y*image.stride + x];

Another way to get and set the pixel value:

float f = image.getBand(i).get(x, y);
...
image.getBand(i).set(x, y, f);

Where i represents the index of the color channel.

Convert a BoofCV image back to BufferedImage:

BufferedImage bufferedImage =
    new BufferedImage(image.width, image.height, BufferedImage.TYPE_4BYTE_ABGR);
BufferedImage bufferedImage = ConvertBufferedImage.convertTo(
    image, bufferedImage, true);

Upvotes: 3

FiReTiTi
FiReTiTi

Reputation: 5898

The option 3 is used by the BufferedImage in Java. It's good for memory as said Andreas, but for image processing and information continuity it's not optimal. The most practical would be:

float[][] img = new float[channels][cols*rows];

Like that, the channels are separated and thus can be processed independently. This representation would be optimal if you want to call native codes.

Upvotes: 1

Andreas
Andreas

Reputation: 159124

You are right, option 3 has a smaller memory footprint.

As for which performs better, you'd have to profile and/or benchmark the options.

Given your statement that row and column counts are large, I'd go with option 3, but wrap the array in a class that knows the dimensions, e.g. called Image.

Upvotes: 1

Related Questions