Articles on image compression often focus on generating the best possible image quality (PSNR) given a fixed compression ratio. I’m curious about getting the best possible compression ratio given a maximum permissible per-pixel error. My instinct is to greedily remove the smallest coefficients in the transformed data, keep track of the error I’ve caused, until I can’t remove any more without passing the maximum error. But I can’t find any papers to confirm it. Can anyone point me to a reference about this problem?
edit
Let me give some more details. I’m trying to compress depth images from 3D scanners, not regular images. Color is not a factor. Depth images tend to have large smooth patches, but accurate discontinuities are important. Some pixels will be empty – outside the scanner’s range or low confidence level – and not require compression.
The algorithm will need to run fast – optimally at 30 fps like the Microsoft Kinect, or at least somewhere in the 100 millisecond area. The algorithm will be included in a library I distribute. I prefer to minimize dependencies, so compression schemes that I can implement myself in a reasonably small amount of code are preferable.
This answer won’t satisfy your request for references, but it’s too long to post as a comment.
First, depth buffer compression for computer generated imagery may apply to your case. Usually this compression is done at the hardware level with a transparent interface, so it’s typically designed to be simple and fast. Given this, it may be worth your while to search for depth buffer compression.
One of the major issues you’re going to have with transform-based compressors (DCTs, Wavelets, etc…) is that there’s no easy way to find compact coefficients that meet your hard maximum error criteria. (The problem you end up with looks a lot like linear programming. Wavelets can have localized behavior in most of their basis vectors which can help somewhat, but it’s still rather inconvenient.) To achieve the accuracy you desire you may need to add on another refinement step but this will also add more computation time, complexity, and will introduce another layer imperfect entropy coding leading to a loss of compression efficiency.
What you want is more akin to lossless compression than lossy compression. In this light, one approach would be to simply throw away the bits under your error threshold: if your maximum allowable error is X and your depths are represented as integers, integer-divide your depths by X and then apply lossless compression.
Another issue you’re facing is the representation of depth — depending on your circumstances it may be a floating point number, an integer, it may be in a projective coordinate system, or even more bizarre.
Given these restrictions, I recommend a scheme like
BTPC as it allows for a more easily adapted wavelet-like scheme where errors are more clearly localized and easier to understand and account for. Additionally, BTPC has shown a great resistance to many types of images and a good ability to handle continuous gradients and sharp edges with low loss of fidelity — exactly the sorts of traits you’re looking for.
Since BTPC is predictive, it doesn’t matter particularly how your depth format is stored — you just need to modify your predictor to take your coordinate system and numeric type (integer vs. floating) into account.
Since BTPC doesn’t do terribly much math, it can run pretty fast on general CPUs, too, although it may not be as easy to vectorize as you’d like. (It sounds like you’re possibly doing low level optimized game programming, so this may be a serious consideration for you.)
If you’re looking for something simpler to implement I’d recommend a “filter” type of approach (similar to PNG) with a Golomb-Rice coder strapped on. Rather than coding the deltas perfectly to end up with lossless compression, you can code to a “good enough” degree. The advantage of doing this as compared to a quantize-then-lossless-encode style compressor is that you can potentially maintain more continuity.