how_to_scan_images

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <sstream>

using namespace std;
using namespace cv;

/************************************************************************
*
/************************************************************************/
Mat& sanImgEffective(Mat &I, const uchar* const table)
{
CV_Assert(I.depth() != sizeof(uchar));

int channels = I.channels();

int nRows = I.rows;
int nCols = I.cols * channels;

if (I.isContinuous()) {

nCols = nRows * nCols;
nRows = 1;
}

uchar* p;
for (int i = 0; i < nRows; ++i) {

p = I.ptr<uchar>(i);

for (int j = 0; j < nCols; ++j) {

p[j] = table[p[j]];
}
}

return I;
}

/************************************************************************
*
/************************************************************************/
Mat& sanImgIterator(Mat &I, const uchar* const table)
{
CV_Assert(I.depth() != sizeof(uchar));

const int channels = I.channels();

switch(channels)
{
case 1: {
MatIterator_<uchar> it, end;

for (it = I.begin<uchar>(), end = I.end<uchar>(); it != end; ++it, ++end) {
*it = table[*it];
}

break;
}

case 3: {
MatIterator_<Vec3b> it, end;

for (it = I.begin<Vec3b>(), end = I.end<Vec3b>(); it != end; ++it, ++end) {
(*it)[0] = table[(*it)[0]];
(*it)[1] = table[(*it)[1]];
(*it)[2] = table[(*it)[2]];
}

break;
}
}

return I;
}

/************************************************************************
*
/************************************************************************/
Mat& sanImgOnTheFly(Mat &I, const uchar* const table)
{
CV_Assert(I.depth() != sizeof(uchar));

int channels = I.channels();
int nRows = I.rows;
int nCols = I.cols;

switch(channels) {

case 1: {
for (int i = 0; i <nRows; ++i) {
for (int j = 0; j < nCols; ++j) {
I.at<uchar>(i, j) = table[I.at<uchar>(i, j)];
}
}
break;
}
break;
case 3: {
Mat_<Vec3b> _I = I;

for (int i = 0; i <nRows; ++i) {
for (int j = 0; j < nCols; ++j) {

_I(i, j)[0] = table[_I(i, j)[0]];
_I(i, j)[1] = table[_I(i, j)[1]];
_I(i, j)[2] = table[_I(i, j)[2]];
}
}

I = _I;
break;
}

}

return I;

}

int main(){

uchar table[256];
int divideWith = 16;

for (int i = 0; i < 256; ++i) {

table[i] = divideWith * (i / divideWith);
}

Mat image = imread("tiger.jpg");
Mat result = image.clone();

cout << "Time of reducing color :" << endl;

//C operator [] method 1-------------------------------------------------------
{
double t;
t = (double)getTickCount();

cv::Mat clone_i = image.clone();
result = sanImgEffective(image, table);
t = 1000*((double)getTickCount() - t)/getTickFrequency();

cout << " C operator [] runs: \n		" << t << " milliseconds."<< endl;
}

//iterator method 2------------------------------------------------------------
{
double t;
t = (double)getTickCount();

cv::Mat clone_i = image.clone();
result = sanImgIterator(image, table);

t = 1000*((double)getTickCount() - t)/getTickFrequency();

cout << " iterator runs: \n		" << t << " milliseconds."<< endl;
}

// on-the-fly method 3--------------------------------------------------------
{
double t;
t = (double)getTickCount();

cv::Mat clone_i = image.clone();
result = sanImgOnTheFly(image, table);

t = 1000*((double)getTickCount() - t)/getTickFrequency();

cout << "on-the-fly address runs: \n		" << t << " milliseconds."<< endl;
}

// lookUpTable method 4--------------------------------------------------------
Mat lookUpTable(1, 256, CV_8U);
uchar* p = lookUpTable.data;
for( int i = 0; i < 256; ++i)
p[i] = table[i];

{
double t;
t = (double)getTickCount();

LUT(image, lookUpTable, result);

t = 1000*((double)getTickCount() - t)/getTickFrequency();

cout << "the LUT f runs: \n		" << t << " milliseconds."<< endl;
}

}