Simple Image Correction for Older Android Cameras

Question

I have an android application where I am trying to let the user capture an image of a document with the native camera and then send it to the server to be made black and white.

In the android app I'm following this example to capture a full size photo from the camera.

The issue I'm having is that an old Nexus 4 camera results in a darker image, and therefore parts of the document are made black instead of white (mostly around the edges of the document). But with a newer Nexus 6 camera there is no issue.

Using this code to change the contrast/brightness works great for increasing the quality of the the Nexus 4 image, but washes out the newer Nexus 6 image.

Is there a way to automatically detect a darker, poor quality image from an older android device in order to apply the image correction only to those images?

Simply calculating the average brightness of the image with this code is thrown off by the possibility of a dark background surrounding a document.

score 1 · Accepted Answer · answered Dec 29 '17 at 15:39

I ended up finding this algorithm in C++ OpenCV and I wrote an implementation in Java for our backend server. It seems to handle darker images from older cameras well. Although it only seems to work for JPG images, not PNGs.

private BufferedImage autoCorrectBrightnessAndContrast(final BufferedImage image) {
    final int[] histogram = makeHistogram(image);

    if (LOG.isDebugEnabled()) {
        LOG.debug("Histogram: {}", Arrays.toString(histogram));
    }

    final int[] cumulativeHistogram = getCumulativeHistogram(histogram);
    /*
     * Finding the minimum and maximum indices in the histogram where the value at the index is greater than a given
     * threshold, computed from CLIP_PERCENT.
     */
    final int min = getMinIndex(cumulativeHistogram);
    final int max = getMaxIndex(cumulativeHistogram);
    LOG.debug("Min: {} Max: {}", min, max);

    /*
     * alpha is the scaling factor, or the amount that we need to expand the histogram graph horizontally so that it
     * fills the entire width. Essentially increasing contrast.
     */
    double alpha = 1;
    if (max != min) {
        alpha = MAX_COLOR / (double) (max - min);
    }
    /*
     * beta is the translating factor, or the amount that we need to slide the histogram graph left or right so that
     * it lines up with the origin. Essentially adjusting brightness.
     */
    final double beta = -min * alpha;

    return adjustBrightnessAndContrast(image, alpha, beta);
}

/**
 * Creates an int array of length MAX_COLOR representing a histogram from the input image. Each index represents the
 * number of pixels of that greyscale shade in the image.
 * 
 * @param image
 *            the bufferedImage to create a histogram from.
 * @return an int array represenation of the histogram.
 * 
 * @see <a href="https://stackoverflow.com/a/10109389/1088659">Plot a histogram for a buffered image</a>
 */
private static int[] makeHistogram(final BufferedImage image) {
    final int[] histogram = new int[MAX_COLOR];

    final ColorSpace colorSpace = image.getColorModel().getColorSpace();
    LOG.debug("Color space type: {}, is RGB = {}", colorSpace.getType(), colorSpace.isCS_sRGB());

    for (int x = 0; x < image.getWidth(); x++) {
        for (int y = 0; y < image.getHeight(); y++) {
            final int color = image.getRGB(x, y);
            final int red =   (color & 0x00ff0000) >> 16;
            final int green = (color & 0x0000ff00) >> 8;
            final int blue =   color & 0x000000ff;
            // Constructing a weighted average of the three color bands
            // based on how much they contribute to the overall brightness
            // of a pixel. (Relative luminance - https://en.wikipedia.org/wiki/Relative_luminance)
            final double greyscaleBrightness = .2126 * red + .7152 * green + .0722 * blue;
            histogram[(int) greyscaleBrightness]++;
        }
    }
    return histogram;
}

/**
 * @param histogram
 * @return an int array representing the cumulative histogram of the given histogram.
 * @see <a href="https://en.wikipedia.org/wiki/Histogram#Cumulative_histogram">Cumulative Histogram</a>
 */
private static int[] getCumulativeHistogram(final int[] histogram) {
    final int[] cumulativeHistogram = new int[histogram.length];

    cumulativeHistogram[0] = histogram[0];
    for (int i = 1; i < histogram.length; i++) {
        cumulativeHistogram[i] = cumulativeHistogram[i - 1] + histogram[i];
    }
    return cumulativeHistogram;
}

/**
 * @param cumulativeHistogram
 * @return the minimum index where the cumulative histogram goes above the threshold set by CLIP_PERCENT.
 */
private static int getMinIndex(final int[] cumulativeHistogram) {
    final int maxValue = cumulativeHistogram[cumulativeHistogram.length - 1];
    final double clipThreshold = CLIP_PERCENT * (maxValue / 100.0) * .5;
    int minIndex = 0;

    while (cumulativeHistogram[minIndex] < clipThreshold) {
        minIndex++;
    }
    return minIndex;
}

/**
 * @param cumulativeHistogram
 * @return the maximum index where the cumulative histogram goes below the threshold set by CLIP_PERCENT.
 */
private static int getMaxIndex(final int[] cumulativeHistogram) {
    final int maxValue = cumulativeHistogram[cumulativeHistogram.length - 1];
    final double clipThreshold = CLIP_PERCENT * (maxValue / 100.0) * .5;
    int maxIndex = cumulativeHistogram.length - 1;

    while (cumulativeHistogram[maxIndex] >= maxValue - clipThreshold) {
        maxIndex--;
    }
    return maxIndex;
}

/**
 * @param image
 * @param alpha
 *            the scaling factor to adjust the contrast.
 * @param beta
 *            the offset factor to adjust the brightness.
 * @return the adjusted image.
 */
private static BufferedImage adjustBrightnessAndContrast(final BufferedImage image, final double alpha, final double beta) {
    BufferedImage processedImage = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
    processedImage = new RescaleOp((float) alpha, (float) beta, null).filter(image, processedImage);
    LOG.debug("alpha: {} beta: {}", (float) alpha, (float) beta);
    return processedImage;
}

score 0 · Answer 2 · answered Nov 21 '17 at 17:06

Probably, the criterion is not brightness, but contrast. In any case, the challenge is hard, and you cannot expect flawless flow, but be ready to handle it via trial and error.

Try to take a picture with normal contrast; if it fails, set a flag to use extra brightness next time. Note that devices out in the wild may have very different camera behaviors, and also photo conditions vary even with the same phone.

You can initialize the flag to high brightness for Nexus 4. Actually, I am not sure if this will hold for all Nexus 4 devices, or only for some.

If your app will be used massively, you can gather statistics for each model and apply it as initial guess when the app is installed.

Simple Image Correction for Older Android Cameras

2 Answers2