實習(xí)第一個任務(wù)就是擺脫opencv钉嘹，寫出圖像的resize算法。難烛芬。隧期。。
現(xiàn)在總結(jié)一下：
由于目前還需要opencv進行圖像的讀取和顯式赘娄，所以還是會用到opencv的庫。之后應(yīng)該慢慢就有公司自己的庫了宏蛉。
圖像的縮放很好理解,就是圖像的放大和縮小遣臼。傳統(tǒng)的繪畫工具中,有一種叫做“放大尺”的繪畫工具，畫家常用它來放大圖畫拾并。當(dāng)然揍堰，在計算機上，我們不再需要用放大尺去放大或縮小圖像了嗅义，把這個工作交給程序來完成就可以了屏歹。下面就來講講計算機怎么來放大縮小圖象；在本文中之碗，我們所說的圖像都是指點陣圖蝙眶，也就是用一個像素矩陣來描述圖像的方法，對于另一種圖像：用函數(shù)來描述圖像的矢量圖，不在本文討論之列幽纷。
越是簡單的模型越適合用來舉例子式塌，我們就舉個簡單的圖像：3X3 的256級灰度圖，也就是高為3個象素友浸，寬也是3個象素的圖像峰尝，每個象素的取值可以是 0－255，代表該像素的亮度收恢，255代表最亮武学，也就是白色，0代表最暗伦意，即黑色劳淆。假如圖像的象素矩陣如下圖所示（這個原始圖把它叫做源圖，Source）：
234 38 22
67 44 12
89 65 63
這個矩陣中默赂，元素坐標(x,y)是這樣確定的沛鸵，x從左到右，從0開始缆八，y從上到下曲掰，也是從零開始，這是圖象處理中最常用的坐標系奈辰，就是這樣一個坐標：
----------------------＞X
|
|
|
|
|
∨Y
如果想把這副圖放大為 4X4大小的圖像栏妖，那么該怎么做呢？那么第一步肯定想到的是先把4X4的矩陣先畫出來再說奖恰，好了矩陣畫出來了吊趾，如下所示，當(dāng)然瑟啃，矩陣的每個像素都是未知數(shù)论泛，等待著我們?nèi)ヌ畛洌ㄟ@個將要被填充的圖的叫做目標圖,Destination）：
? ? ? ?
? ? ? ?
? ? ? ?
? ? ? ?
然后要往這個空的矩陣里面填值了，要填的值從哪里來來呢蛹屿？是從源圖中來屁奏，好，先填寫目標圖最左上角的象素错负，坐標為（0坟瓢，0），那么該坐標對應(yīng)源圖中的坐標可以由如下公式得出：
srcX=dstX* (srcWidth/dstWidth) , srcY = dstY * (srcHeight/dstHeight)
好了犹撒，套用公式折联，就可以找到對應(yīng)的原圖的坐標了(0(3/4),0(3/4))=>(00.75,00.75)=>(0,0)
,找到了源圖的對應(yīng)坐標,就可以把源圖中坐標為(0,0)處的234象素值填進去目標圖的(0,0)這個位置了。
接下來,如法炮制,尋找目標圖中坐標為(1,0)的象素對應(yīng)源圖中的坐標,套用公式:
(10.75,00.75)=>(0.75,0)
結(jié)果發(fā)現(xiàn),得到的坐標里面竟然有小數(shù),這可怎么辦?計算機里的圖像可是數(shù)字圖像,象素就是最小單位了,象素的坐標都是整數(shù),從來沒有小數(shù)坐標识颊。這時候采用的一種策略就是采用四舍五入的方法（也可以采用直接舍掉小數(shù)位的方法）诚镰，把非整數(shù)坐標轉(zhuǎn)換成整數(shù)，好，那么按照四舍五入的方法就得到坐標（1怕享，0）执赡，完整的運算過程就是這樣的：
(10.75,00.75)=>(0.75,0)=>(1,0)
那么就可以再填一個象素到目標矩陣中了，同樣是把源圖中坐標為(1,0)處的像素值38填入目標圖中的坐標函筋。
依次填完每個象素沙合，一幅放大后的圖像就誕生了，像素矩陣如下所示：
234 38 22 22
67 44 12 12
89 65 63 63
89 65 63 63
這種放大圖像的方法叫做最臨近插值算法跌帐，這是一種最基本首懈、最簡單的圖像縮放算法，效果也是最不好的谨敛，放大后的圖像有很嚴重的馬賽克究履，縮小后的圖像有很嚴重的失真；效果不好的根源就是其簡單的最臨近插值方法引入了嚴重的圖像失真脸狸，比如最仑，當(dāng)由目標圖的坐標反推得到的源圖的的坐標是一個浮點數(shù)的時候，采用了四舍五入的方法炊甲，直接采用了和這個浮點數(shù)最接近的象素的值泥彤，這種方法是很不科學(xué)的，當(dāng)推得坐標值為 0.75的時候卿啡，不應(yīng)該就簡單的取為1吟吝，既然是0.75，比1要小0.25 颈娜，比0要大0.75 ,那么目標象素值其實應(yīng)該根據(jù)這個源圖中虛擬的點四周的四個真實的點來按照一定的規(guī)律計算出來的剑逃，這樣才能達到更好的縮放效果。雙線型內(nèi)插值算法就是一種比較好的圖像縮放算法官辽，它充分的利用了源圖中虛擬點四周的四個真實存在的像素值來共同決定目標圖中的一個像素值蛹磺，因此縮放效果比簡單的最鄰近插值要好很多。
基于此原理的代碼如下：
/*********************Resize_INTER_NN******************************************/
//功能：利用最臨近插值修改圖像尺寸
//參數(shù)：原圖像,目標圖像野崇，目標長称开，目標寬
void mcv::Resize_INTER_NN(mcv::Image &src, mcv::Image &dst, unsigned int width, unsigned int heigth)
{
matDst1 = Mat(Size(width, heigth), matSrc.type(), Scalar::all(0));//為了顯示使用opencv，Size（width乓梨，heigth）
dst.height = matDst1.rows;
dst.width = matDst1.cols;
dst.channel = matDst1.channels();
dst.data = matDst1.data;
//縮放倍數(shù)
double scale_x = (double)src.width / dst.width;
double scale_y = (double)src.height / dst.height;
//最臨近插值
//unsigned char * ptr = dst.data;//儲存基地址 改進后不需要了
for (int i = 0; i < dst.width; i++)
{
int sx = floor(i * scale_x);
sx = std::min(sx, src.width - 1);
for (int j = 0; j < dst.height; j++)
{
int sy = floor(j * scale_y);
sy = std::min(sy, src.height - 1);
for (int k = 0; k < dst.channel; k++)
{
if ((i == 1) && (j == 0) && (k == 0))
waitKey(1000);
//dst.data = ptr + i*dst.channel + j*dst.width*dst.channel + k;
*(dst.data + i*dst.channel + j*dst.width*dst.channel + k) = *(src.data + sx*src.channel + sy*src.channel*src.width + k);//w*h*ch變換到1維中
}
}
}
}
結(jié)果如下
肉眼看不出，對比十六進制：
看出基于原理寫的代碼和opencv出來的結(jié)果相差很多清酥，這樣是交不了差的扶镀。。焰轻。
插值方法：
- CV_INTER_NN - 最近鄰插值,
- CV_INTER_LINEAR - 雙線性插值 (缺省使用)
- CV_INTER_AREA - 使用象素關(guān)系重采樣臭觉。當(dāng)圖像縮小時候，該方法可以避免波紋出現(xiàn)。當(dāng)圖像放大時蝠筑，類似于 CV_INTER_NN 方法..
- CV_INTER_CUBIC - 立方插值.
下面我放出關(guān)鍵代碼狞膘，如果需要完整的請私信我。
//******************定義的臨時圖像類型*************//
class Image{
public:
unsigned char* data;
int height;
int width;
int depth;
int step;
int dims;
int elemSize;
int channel;
};//以后慢慢豐富
//******************動態(tài)管理內(nèi)存****************//
template<typename _Tp, msize_t fixed_size = 4096 / sizeof(_Tp)+8> class mAutoBuffer
{
public:
typedef _Tp value_type;
enum { buffer_padding = (int)((16 + sizeof(_Tp)-1) / sizeof(_Tp)) };
//! the default contructor
mAutoBuffer();
//! constructor taking the real buffer size
mAutoBuffer(msize_t _size);
//! destructor. calls deallocate()
~mAutoBuffer();
//! allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used
void mallocate(msize_t _size);
//! deallocates the buffer if it was dynamically allocated
void mdeallocate();
//! returns pointer to the real buffer, stack-allocated or head-allocated
operator _Tp* ();
//! returns read-only pointer to the real buffer, stack-allocated or head-allocated
operator const _Tp* () const;
protected:
//! pointer to the real buffer, can point to buf if the buffer is small enough
_Tp* ptr;
//! size of the real buffer
msize_t size;
//! pre-allocated buffer
_Tp buf[fixed_size + buffer_padding];
};
template<typename _Tp> static inline _Tp* mallocate(msize_t n)
{
return new _Tp[n];
}
template<typename _Tp> static inline void mdeallocate(_Tp* ptr, msize_t)
{
delete[] ptr;
}
template<typename _Tp, msize_t fixed_size> inline mAutoBuffer<_Tp, fixed_size>::mAutoBuffer()
{
ptr = buf;
size = fixed_size;
}
template<typename _Tp, msize_t fixed_size> inline mAutoBuffer<_Tp, fixed_size>::mAutoBuffer(msize_t _size)
{
ptr = buf;
size = fixed_size;
mallocate(_size);
}
template<typename _Tp, msize_t fixed_size> inline mAutoBuffer<_Tp, fixed_size>::~mAutoBuffer()
{
mdeallocate();
}
template<typename _Tp, msize_t fixed_size> inline void mAutoBuffer<_Tp, fixed_size>::mallocate(msize_t _size)
{
if (_size <= size)
return;
mdeallocate();
if (_size > fixed_size)
{
ptr = mcv::mallocate<_Tp>(_size);
size = _size;
}
}
template<typename _Tp, msize_t fixed_size> inline void mAutoBuffer<_Tp, fixed_size>::mdeallocate()
{
if (ptr != buf)
{
mcv::mdeallocate<_Tp>(ptr, size);
ptr = buf;
size = fixed_size;
}
}
template<typename _Tp, msize_t fixed_size> inline mAutoBuffer<_Tp, fixed_size>::operator _Tp* ()
{
return ptr;
}
template<typename _Tp, msize_t fixed_size> inline mAutoBuffer<_Tp, fixed_size>::operator const _Tp* () const
{
return ptr;
}
void mcv::Resize_NN(mcv::Image &src, mcv::Image &dst, int height, int width)
{
matDst1 = Mat(Size(width, height), matSrc.type(), Scalar::all(0));
dst.height = matDst1.rows;
dst.width = matDst1.cols;
dst.channel = matDst1.channels();
dst.step = matDst1.step;
dst.dims = matDst1.dims;
dst.depth = matDst1.depth();
dst.elemSize = (int)matDst1.elemSize();
dst.data = matDst1.data;
//縮放倍數(shù)
double inv_scale_x = (double)dst.width / src.width;
double inv_scale_y = (double)dst.height / src.height;
double scale_x = 1. / inv_scale_x, scale_y = 1. / inv_scale_y;
int depth = src.depth, cn = src.channel;
int fx, fy;
int k, sx, sy, dx, dy;
mcv::mAutoBuffer<int> _x_ofs(dst.width);
int* x_ofs = _x_ofs;
fx = inv_scale_x; fy = inv_scale_y;
int pix_size = src.elemSize;
int pix_size4 = (int)(pix_size / sizeof(int));
double ifx = 1. / fx, ify = 1. / fy;
int x1;
for (x1 = 0; x1 < dst.width; x1++)
{
int sx = floor(x1*ifx);
x_ofs[x1] = std::min(sx, src.width - 1)*pix_size;
}
mcv::mRange range(0, dst.height);
int y, x;
for (int y = range.start; y < range.end; y++)
{
uchar* D = dst.data + dst.step*y;
int sy = std::min(cvFloor(y*ify), dst.height - 1);
const uchar* S = src.data + src.step*sy;
switch (pix_size)
{
case 1:
for (x = 0; x <= dst.width - 2; x += 2)
{
uchar t0 = S[x_ofs[x]];
uchar t1 = S[x_ofs[x + 1]];
D[x] = t0;
D[x + 1] = t1;
}
for (; x < dst.width; x++)
D[x] = S[x_ofs[x]];
break;
case 2:
for (x = 0; x < dst.width; x++)
*(ushort*)(D + x * 2) = *(ushort*)(S + x_ofs[x]);
break;
case 3:
for (x = 0; x < dst.width; x++, D += 3)
{
const uchar* _tS = S + x_ofs[x];
D[0] = _tS[0]; D[1] = _tS[1]; D[2] = _tS[2];
}
break;
case 4:
for (x = 0; x < dst.width; x++)
*(int*)(D + x * 4) = *(int*)(S + x_ofs[x]);
break;
case 6:
for (x = 0; x < dst.width; x++, D += 6)
{
const ushort* _tS = (const ushort*)(S + x_ofs[x]);
ushort* _tD = (ushort*)D;
_tD[0] = _tS[0]; _tD[1] = _tS[1]; _tD[2] = _tS[2];
}
break;
case 8:
for (x = 0; x < dst.width; x++, D += 8)
{
const int* _tS = (const int*)(S + x_ofs[x]);
int* _tD = (int*)D;
_tD[0] = _tS[0]; _tD[1] = _tS[1];
}
break;
case 12:
for (x = 0; x < dst.width; x++, D += 12)
{
const int* _tS = (const int*)(S + x_ofs[x]);
int* _tD = (int*)D;
_tD[0] = _tS[0]; _tD[1] = _tS[1]; _tD[2] = _tS[2];
}
break;
default:
for (x = 0; x < dst.width; x++, D += pix_size)
{
const int* _tS = (const int*)(S + x_ofs[x]);
int* _tD = (int*)D;
for (int k = 0; k < pix_size4; k++)
_tD[k] = _tS[k];
}
}
}
}
對比結(jié)果
完美~
這個resizeNN可以實現(xiàn)最鄰近插值什乙，而且可以讀取灰度圖挽封，浮點型圖片。
待續(xù)...
