Confusion regarding Image compression algorithms

I had been reading a webpage on Image Compression (Lossy and Non-lossy).

Now this is my problem, I was successful in making a project on Face detection using opencv - however - my Project Guide is not satisfied - my project simply captures the frames from a Capture device [ webcam ] and passes frames in a function to detect the Faces in those frames and outputs the detect frames in Windows.

My Project Guide wants me to implement some algorithm either of image compression or morphing , etc. but was not happy on seeing such heavy usage of the Library -

So what I would like to know - is it possible to code using C or C++ - image compression algorithms? If yes would not the code size 开发者_StackOverflow社区be huge? (my project is supposed to be a minor one)

Please help me out, suppose I want to use the RLE compression using C++ how should I go about it?

You want to invent your own image compression or implement one of the standard ones? ( I assume this is for some sort of class/assignment, you wouldn't do this in the real world!)

You can compress simple images a little using something like Run-Length, especially if you can reduce the number of colours ie. a cartoon or graphic, but for a real photo style image it isn't going to work - that's why complex lossy techniques like jpeg or wavelets were invented.

It's very possible, and RLE compression is quite easy. If you want to look at a relatively straight-forward approach to RLE that won't use a lot of code, look at implementing a version of packbits.

Here's another link as well: http://michael.dipperstein.com/rle/index.html (includes an implementation with source-code for both traditional RLE and packbits)

BTW, keep in mind that you could, with noisy data, actually end up with more data than uncompressed using RLE schemes. For most "real-world" images though that have some form of low-pass filtering applied and a relatively good signal-to-noise ration (i.e,. above 40db), you should expect around 1.5:1 to 1.7:1 compression ratios.

Another option for lossless compression would be huffman-encoding ... that algorithm is more tolerant of noisy images, in that it generally prevents the data-expansion that could occur with those types of images when encoded with a RLE compression algorithm.

Finally, you didn't mention whether you were working with color or grayscale images ... if it's a color image, remember that you will find much greater redundancy if you compress each color-channel in a planar-color-channel image, rather than trying to compress contiguous RGB data.

RLE is the best way to go here. Even the "simplest" compression algorithms are non-trivial and require in-depth knowledge of color space transforms, discrete sin/cosine transforms, entropy, etc.

Back to RLE... to loop through pixesls use something like this:

cv::Mat img = cv::imread("lenna.png");
for(int i=0; i < img.rows; i++)
    for(int j=0; i < img.cols; j++)
        // You can now access the pixel value with cv::Vec3b
        std::cout << img.at<cv::Vec3b>(i,j)[0] << " " << img.at<cv::Vec3b>(i,j)[1] << " " << img.at<cv::Vec3b>(i,j)[2] << std::endl;

Count the number of similar pixels in a row and store them in any data structure (maybe a < #Occurences, Vec3b > tuple in a vector?). Once you have your final vector, don't forget to store the size of your image somewhere with the aforementioned vector (maybe in a simple compressedImage struct) and voilà, you just compressed an image. To store it in a file, I suggest you use boost::serialize or something similar.

Your final struct may look something similar to:

struct compressedImage {
  int height;
  int width;
  vector< pair<int, Vec3b> > data;
};

Happy coding!

You want to implement a compression based on colour reduction with a space-filling-curve or a spatial index. A si reduce the 2d complexity to a 1d complexity and it looks like a quadtree and a bit like a fractal. You want to look for Nick's hilbert curve quadtree spatial index blog!

Here is another interesting RLE encoding idea: Lossless hierarchical run length encoding. Maybe that's something for you?

if you need to abstract the raster type, you can use GDAL C++ library. Here is the list of supported by default or on request raster formats:

http://gdal.org/formats_list.html