herrDeng網內搜尋

自訂搜尋

Ads

2016年11月25日 星期五

Ex9 處理BMP圖檔的C++程式(未用任何library)


要處理的511x511未壓縮tiffany bmp圖檔,
作業為產生R、G、B、半灰半彩的圖檔


0)class ImageMarix:



1)使用windows.h中的
struct BITMAPFILEHEADER




2)使用windows.h中的
struct BITMAPINFOHEADER



3)class ImageMarix 中的變數成員與建構子,注意rowsize必須是4的倍數,一個pixel有3 bytes RGB的顏色,不足4的倍數,往上padding。



4)透過seekg移動游標至檔尾,透過tellg來告知圖檔實際大小,透個read來讀取表頭、圖檔資料表圖、像素資料。像素的排列順序是GBR,先由左而右、再下而上,與座標再下而上,與座標不同,也與矩陣排列不同。



5)透個write來寫表頭、圖檔資料表圖、像素資料



6)簡易的轉灰階函數convert2gray,像素的排列順序是GBR,公式為
gray=(BYTE)(0.2989*R + 0.5870*G + 0.1140*B+0.5)



更一般的版本。自訂windows常用的BITMAPFILEHEADER、BITMAPINFOHEADER,
可在windows、linux上執行。要加上前置處理器,對齊struct, class中成員,如
#pragma pack(push)
#pragma pack(2)
....
#pragma pack(pop)

18 則留言:

A10433018 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

A10433024 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

A10433018 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

B10133186 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}

ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2convertAndgray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10433011 提到...

ImageMatrix convert2gg(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2bb(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2rr(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2cc(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y < m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1]
= mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}
int main(){
cout<<sizeof(BITMAPFILEHEADER)<<endl;
cout<<sizeof(BITMAPINFOHEADER)<<endl;
ImageMatrix m, mm;
m.Load("tiffany511.bmp");
m.Save("tiffany511(copy).bmp");
mm=convert2gray(m);
mm.Save("tiffany2.bmp");
mm = convert2gg(m);
mm.Save("tiffanyG.bmp");
mm = convert2rr(m);
mm.Save("tiffanyR.bmp");
mm = convert2bb(m);
mm.Save("tiffanyB.bmp");
mm = convert2cc(m);
mm.Save("tiffanyC.bmp");
system("Pause");
return 0;
}

B10433092 提到...

ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm=ImageMatrix(m.height, m.width);
for(int y=0; y<m.height; y++)
for(int x=0; x<m.rowsize; x+=3){
BYTE B=m.term[y*m.rowsize+x];
BYTE G=m.term[y*m.rowsize+x+1];
BYTE R=m.term[y*m.rowsize+x+2];
BYTE gray=(BYTE)(0.2989*R + 0.5870*G + 0.1140*B+0.5);
mm.term[y*m.rowsize+x]=
mm.term[y*m.rowsize+x+1]=
mm.term[y*m.rowsize+x+2]=gray;
}
return mm;
}

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}

ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}

B10333054 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 1] = G;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = G;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 1] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 0] = G;
}
return mm;
}
ImageMatrix convert2half(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x + 0] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10333016 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 1] = G;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = G;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 1] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 0] = G;
}
return mm;
}
ImageMatrix convert2half(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x + 0] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10333049 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 1] = G;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = G;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 1] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 0] = G;
}
return mm;
}
ImageMatrix convert2half(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x + 0] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10533065 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 1] = G;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = G;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 1] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 0] = G;
}
return mm;
}
ImageMatrix convert2half(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x + 0] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10433080 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 1] = G;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x + 0] = mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = G;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x + 0];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x + 1] = mm.term[y*m.rowsize + x + 2] = 0;
mm.term[y*m.rowsize + x + 0] = G;
}
return mm;
}
ImageMatrix convert2half(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x + 0] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

b10233127 提到...

ImageMatrix convert2gg(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2bb(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2rr(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2cc(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y < m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1]
= mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}
int main(){
cout<<sizeof(BITMAPFILEHEADER)<<endl;
cout<<sizeof(BITMAPINFOHEADER)<<endl;
ImageMatrix m, mm;
m.Load("tiffany511.bmp");
m.Save("tiffany511(copy).bmp");
mm=convert2gray(m);
mm.Save("tiffany2.bmp");
mm = convert2gg(m);
mm.Save("tiffanyG.bmp");
mm = convert2rr(m);
mm.Save("tiffanyR.bmp");
mm = convert2bb(m);
mm.Save("tiffanyB.bmp");
mm = convert2cc(m);
mm.Save("tiffanyC.bmp");
system("Pause");
return 0;
}

B10233108 提到...

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y < m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}

ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2convertAndgray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}

B10433103 提到...

ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm=ImageMatrix(m.height, m.width);
for(int y=0; y<m.height; y++)
for(int x=0; x<m.rowsize; x+=3){
BYTE B=m.term[y*m.rowsize+x];
BYTE G=m.term[y*m.rowsize+x+1];
BYTE R=m.term[y*m.rowsize+x+2];
BYTE gray=(BYTE)(0.2989*R + 0.5870*G + 0.1140*B+0.5);
mm.term[y*m.rowsize+x]=
mm.term[y*m.rowsize+x+1]=
mm.term[y*m.rowsize+x+2]=gray;
}
return mm;
}

ImageMatrix convert2green(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}

ImageMatrix convert2blue(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2red(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}

B10233082 唐偉強 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

b10233072黃宥婕 提到...

ImageMatrix convert2gg(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2bb(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2rr(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2cc(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x < m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y < m.height / 2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1]
= mm.term[y*m.rowsize + x + 2] = gray;
else{
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R;
}
}
return mm;
}
int main(){
cout<<sizeof(BITMAPFILEHEADER)<<endl;
cout<<sizeof(BITMAPINFOHEADER)<<endl;
ImageMatrix m, mm;
m.Load("tiffany511.bmp");
m.Save("tiffany511(copy).bmp");
mm=convert2gray(m);
mm.Save("tiffany2.bmp");
mm = convert2gg(m);
mm.Save("tiffanyG.bmp");
mm = convert2rr(m);
mm.Save("tiffanyR.bmp");
mm = convert2bb(m);
mm.Save("tiffanyB.bmp");
mm = convert2cc(m);
mm.Save("tiffanyC.bmp");
system("Pause");
return 0;
}

b10233074 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

B10233077 提到...

ImageMatrix convert2g(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);

mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2b(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = 0;
}
return mm;
}
ImageMatrix convert2r(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
mm.term[y*m.rowsize + x] = 0;
mm.term[y*m.rowsize + x + 1] = 0;
mm.term[y*m.rowsize + x + 2] = R;
}
return mm;
}
ImageMatrix convert2gray(ImageMatrix m){
ImageMatrix mm = ImageMatrix(m.height, m.width);
for (int y = 0; y<m.height; y++)
for (int x = 0; x<m.rowsize; x += 3){
BYTE B = m.term[y*m.rowsize + x];
BYTE G = m.term[y*m.rowsize + x + 1];
BYTE R = m.term[y*m.rowsize + x + 2];
BYTE gray = (BYTE)(0.2989*R + 0.5870*G + 0.1140*B + 0.5);
if (y<m.height/2)
mm.term[y*m.rowsize + x] = mm.term[y*m.rowsize + x + 1] =
mm.term[y*m.rowsize + x + 2] = gray;
else{mm.term[y*m.rowsize + x] = B;
mm.term[y*m.rowsize + x + 1] = G;
mm.term[y*m.rowsize + x + 2] = R; }
}
return mm;
}

Related Posts Plugin for WordPress, Blogger...

熱門文章