第８章 カラー・ディザリング

【リスト8-1】  8色を表示するプログラム
#include "myWin.h"
#include "math.h"
#define XST 420
#define YST 10
#define GWIDTH 400
#define GHIGHT 400
#define RED(X) (X & 0xFF)
#define GREEN(X) ((X>>8) & 0xFF)
#define BLUE(X) ((X>>16) & 0xFF)
static HBITMAP hBM[2];static HDC hBuff[2]; 
static BITMAP bM[2];
void clearBitmap(int i){//ビットマップのクリア
	SelectObject(hBuff[i], GetStockObject(NULL_PEN));
	PatBlt(hBuff[i], 0,0,GWIDTH,GHIGHT,WHITENESS);//黒塗り
}
void createBitmap(HWND hw){//ビットマップの設定
	HDC hdc=GetDC(hw);
	for(int i=0;i<2;i++){
		hBM[i]=CreateCompatibleBitmap(hdc,GWIDTH,GHIGHT);
		hBuff[i]=CreateCompatibleDC(hdc); SelectObject(hBuff[i], hBM[i]);
		clearBitmap(i);
	}
}

int pixel(int i, int j){//画像1からピクセルを取り出す
	return GetPixel(hBuff[1], i,j);
}
void setPixel(int i, int j, COLORREF C){//画像0にピクセルを設定する
	SetPixel(hBuff[0], i,j, C);
}
void drawColor1(){
	int ist=0, size=40;
	for(int r=0;r<=1;r++)for(int g=0;g<=1;g++)for(int b=0;b<=1;b++){
		int C=RGB(r*255, g*255, b*255);
		for(int i=0;i<size;i++)for(int j=0;j<size;j++) setPixel(ist+i,j, C);
		ist+=size;
	}
}
void procLButtonDown(HWND hw, WPARAM wp,LPARAM lp){
	drawColor1();
	InvalidateRect(hw,NULL,TRUE);
}
void procRButtonDown(HWND hw, WPARAM wp,LPARAM lp){
	clearBitmap(0);//画像0をクリア
    InvalidateRect(hw,NULL,TRUE);
}
void procCreate(HWND hw, WPARAM wp,LPARAM lp){//初期処理
	createBitmap(hw);MoveWindow(hw,0,0,850,460,TRUE);
	hBM[1]=LoadBitmap(hInstance, TEXT("suzume"));//画像1に表示
	GetObject(hBM[1],sizeof(BITMAP), &bM[1]);
    InvalidateRect(hw,NULL,TRUE);
}
void procPaint(HWND hw, WPARAM wp,LPARAM lp){//画面表示
	PAINTSTRUCT ps;	
	HDC hdc  = BeginPaint(hw,&ps);
	SelectObject(hBuff[0],hBM[0]);SelectObject(hBuff[1],hBM[1]);
	BitBlt(hdc,10,YST,GWIDTH, GHIGHT, hBuff[0], 0,0,SRCCOPY);
	BitBlt(hdc,XST,YST,GWIDTH, GHIGHT, hBuff[1], 0,0,SRCCOPY);
	EndPaint(hw,&ps);
}

LRESULT CALLBACK WndProc(HWND hw, UINT msg, WPARAM wp,LPARAM lp){
	switch(msg){
 	case WM_DESTROY : PostQuitMessage(0)  ; return 0;
	case WM_CREATE  : procCreate(hw,wp,lp); return 0;
	case WM_LBUTTONDOWN  : procLButtonDown(hw,wp,lp); return 0;
	case WM_RBUTTONDOWN  : procRButtonDown(hw,wp,lp); return 0;
	case WM_PAINT   : procPaint (hw,wp,lp); return 0;
	}
	return DefWindowProc(hw,msg,wp,lp);
}

【リスト8-2】  64色を8色の2×2ディザ行列で表示
#define NDITHX 2
#define NDITHY 2
void setDitherMat(int M[][NDITHY], double DM[][NDITHY], int CMAX){
	double NM=1.0+(double)(NDITHX*NDITHY), DV = CMAX;
	for(int i=0;i<NDITHX;i++)for(int j=0;j<NDITHY;j++){
		DM[i][j] = DV * (1.0+(double)M[i][j])/NM;
	}
}
int BPP(int r, int N){ return (int)( (255.0/(double) (N-1))*r);}
void drawColor2(int yst){
int ist=0,jst=0, size=24;
	for(int r=0;r<4;r++){
		for(int g=0;g<4;g++)for(int b=0;b<4;b++){
			int C=RGB(BPP(r,4),BPP(g,4),BPP(b,4));
			for(int i=0;i<size;i++)
					for(int j=0;j<size;j++) setPixel(ist+i,j+jst+yst, C);
			ist+=size;
		}
		ist=0;jst+=size;
	}
}
int DTCL(int R, double DM[][NDITHY], int x, int y){
    return 	(R>=DM[x][y])? 0xFF: 0;	
} 
void drawColor2D(int yst){
	double DM[NDITHX][NDITHY];
	int M[NDITHX][NDITHY]={{0,3},{2,1}}; 
	setDitherMat(M, DM, 255);
	int ist=0,jst=0, size=24;
	for(int r=0;r<4;r++){
		for(int g=0;g<4;g++) for(int b=0;b<4;b++){
				int R=BPP(r,4), G=BPP(g, 4), B=BPP(b,4);
				int RR, GG, BB;
				for(int i=0;i<size;i++)for(int j=0;j<size;j++) {
					int x =i % NDITHX, y = j % NDITHY;
					RR=DTCL(R, DM, x, y);
					GG=DTCL(G, DM, x, y);
					BB=DTCL(B, DM, x, y);
					setPixel(ist+i,j+jst+yst, RGB(RR,GG,BB));
				}
				ist+=size;
		}
		ist=0;jst+=size;
	}
}
void procLButtonDown(HWND hw, WPARAM wp,LPARAM lp){
	drawColor2(0);
	drawColor2D(120);
	InvalidateRect(hw,NULL,TRUE);
}
  
(4×4のディザ行列で表現)

#define NDITHX 4
#define NDITHY 4
int M[NDITHX][NDITHY]={{0,12,3,15},{8,4,11,7},{2,14,1,13},{10, 6, 9,5}};
setDitherMat(M, DM, 255);//ここは2×2と同じ
  
(乱数4×4配列ディザ行列で表現)

#define NDITHX 4
#define NDITHY 4
#define frand()((double) rand()/(RAND_MAX+1))
void randomDitherMap(double DM[][NDITHY], int CMAX, int L, int H,int S){
	double R=CMAX-H-L, ST=L, tt=0;srand(S);
	for(int j=0;j<NDITHY; j++)
		for(int i=0;i<NDITHX; i++)DM[i][j]=frand()*R+ST;	
}
randomDitherMap(DM, 255, 50, 20,1);

【リスト8-3】  8色を表示するプログラム
#define NDITHX 4
#define NDITHY 4
void setDitherMat(int M[][NDITHY], double DM[][NDITHY], int CMAX){
	double NM=1.0+(double)(NDITHX*NDITHY), DV = CMAX;
	for(int i=0;i<NDITHX;i++)for(int j=0;j<NDITHY;j++){
		DM[i][j] = DV * (1.0+(double)M[i][j])/NM;
	}
}
int BPP(int r, int N){ return (int)( (255.0/(double) (N-1))*r);}
int DTCL(int R, double DM[][NDITHY], int x, int y){
    return 	(R>=DM[x][y])? 0xFF: 0;	
}
void drawColor256(int yst){
	int ist=0,jst=0, size=12;
	for(int r=0;r<8;r++){
		for(int g=0;g<8;g++) for(int b=0;b<4;b++){
				int C=RGB(BPP(r,8),BPP(g,8),BPP(b,4));
				for(int i=0;i<size;i++)
					for(int j=0;j<size;j++) setPixel(ist+i,j+jst+yst, C);
				ist+=size;
		}
		ist=0;jst+=size;
	}
}
void drawColor256D(int yst){
   double DM[NDITHX][NDITHY];
	int M[NDITHX][NDITHY]={{0,12,3,15},{8,4,11,7},{2,14,1,13},{10, 6, 9,5}};
	double DM[NDITHX][NDITHY];setDitherMat(M, DM, 255);
	int ist=0,jst=0, size=12;
	for(int r=0;r<=7;r++){
		for(int g=0;g<=7;g++)for(int b=0;b<=3;b++){
				int R=BPP(r,8), G=BPP(g, 8), B=BPP(b,4);
				int RR, GG, BB;
				for(int i=0;i<size;i++)for(int j=0;j<size;j++) {
					int x =i % NDITHX, y = j % NDITHY;
					RR=DTCL(R, DM, x, y);
					GG=DTCL(G, DM, x, y);
					BB=DTCL(B, DM, x, y);
					setPixel(ist+i,j+jst+yst, RGB(RR,GG,BB));
				}
				ist+=size;
		}
		ist=0;jst+=size;
	}
}
void procLButtonDown(HWND hw, WPARAM wp,LPARAM lp){
		drawColor256(0);	drawColor256D(120);
	 InvalidateRect(hw,NULL,TRUE);
}
  
(3×3ディザ行列を使う方法)

#define NDITHX 3
#define NDITHY 3
int M[NDITHX][NDITHY]={{5,0,3},{2,8,6},{7,4,1}};

【リスト8-4】 減色表示のための関数
void decreaseColor(int N){
	int C, R,G,B, D=256/N, DX=255/(N-1);
	for(int j=0;j<GHIGHT;j++)for(int i=0;i<GWIDTH;i++){
		C=pixel(i,j); R=RED(C); G=GREEN(C); B=BLUE(C);
		R=(R/D)*DX; G=(G/D)*DX; B=(B/D)*DX; 	C=RGB(R, G,B);
	    setPixel(i,j, C);
	}
}
void color8(){ decreaseColor(2);}
void color64(){decreaseColor(4);}
void color12bits(){decreaseColor(16);}
void color15bits(){decreaseColor(32);}

【リスト8-5】 256色用の減色表示のための関数
void color256(){
int D8=256/8, D4=256/4, DX8=255/7, DX4=255/3;
	for(int j=0;j<GHIGHT;j++)for(int i=0;i<GWIDTH;i++){
		int C=pixel(i,j),R=RED(C), G=GREEN(C), B=BLUE(C),RR,GG,BB;
		RR=(R/D8)*DX8; GG=(G/D8)*DX8; BB=(B/D4)*DX4;
		C=RGB(RR, GG,BB);				
	    setPixel(i,j, C);
	}
}

【リスト8-6】 一般の階調にディザ行列を適用するための関数
int DTCL(int X, int MAX, int MIN, double DM[][NDITHY], int x, int y){
    return ((255*(X-MIN)/(MAX-MIN))>=DM[x][y])? MAX: MIN;	
}

【リスト8-7】 8色による64色ディザリング(2×2ディザ行列)
#define NDITHX 2
#define NDITHY 2
void setDitherMat(int M[][NDITHY], double DM[][NDITHY], int CMAX){
	double NM=1.0+(double)(NDITHX*NDITHY), DV = CMAX;
	for(int i=0;i<NDITHX;i++)for(int j=0;j<NDITHY;j++){
		DM[i][j] = DV * (1.0+(double)M[i][j])/NM;
	}
}
int DTCL(int X, int MAX, int MIN, double DM[][NDITHY], int x, int y){
    return ((255*(X-MIN)/(MAX-MIN))>=DM[x][y])? MAX: MIN;	
}
void color64D(){
	double DM[NDITHX][NDITHY];
	int M[NDITHX][NDITHY]={{0,3},{2,1}}; setDitherMat(M, DM, 255);
	int C, R, G, B, RR, GG, BB, D=256/4,DX=255/3;
	for(int j=0;j<GHIGHT;j+=NDITHY)for(int i=0;i<GWIDTH;i+=NDITHX){
		for(int x =0; x<NDITHX; x++)for(int y=0;y<NDITHY;y++){
			C=pixel(i+x,j+y),R=RED(C), G=GREEN(C), B=BLUE(C);
		RR=(R/D)*DX; GG=(G/D)*DX;BB=(B/D)*DX;if(BB<0) BB=0;
	   	  R=DTCL(RR, 0xFF, 0, DM, x, y); 
		  G=DTCL(GG, 0xFF, 0, DM, x, y); 
		  B=DTCL(BB,  0xFF, 0,DM, x, y);
		  setPixel(i + x, j + y, RGB(R, G,B));
		}
	}
}

【リスト8-8】 8色による256色ディザリング(2×2ディザ行列)
void color256D(){
	double DM[NDITHX][NDITHY];
	int M[NDITHX][NDITHY]={{0,3},{2,1}};
	setDitherMat(M, DM, 255);
	int C, R, G, B, RR, GG, BB,D8=256/8, D4=256/4,DX8=255/7, DX4=255/3;
	for(int j=0;j<GHIGHT;j+=NDITHY)for(int i=0;i<GWIDTH;i+=NDITHX){
		for(int x =0; x<NDITHX; x++)for(int y=0;y<NDITHY;y++){
			C=pixel(i+x,j+y),R=RED(C), G=GREEN(C), B=BLUE(C);
		RR=(R/D8)*DX8; GG=(G/D8)*DX8;BB=(B/D4)*DX4;
	  	  R=DTCL(RR, 0xFF, 0, DM, x, y);
		  G=DTCL(GG, 0xFF, 0, DM, x, y); 
		  B=DTCL(BB, 0xFF, 0, DM, x, y);
		  setPixel(i + x, j + y, RGB(R, G,B));
		}
	}
}

(3×3ディザ行列を使う)

#define NDITHX 3
#define NDITHY 3
int M[NDITHX][NDITHY]={{5,0,3},{2,8,6},{7,4,1}};
  
【リスト8-9】 フルカラーを64色3×3ディザ行列で表現
#define NDITHX 3
#define NDITHY 3
void setDitherMat(int M[][NDITHY], double DM[][NDITHY], int CMAX){
	double NM=1.0+(double)(NDITHX*NDITHY), DV = CMAX;
	for(int i=0;i<NDITHX;i++)for(int j=0;j<NDITHY;j++){
		DM[i][j] = DV * (1.0+(double)M[i][j])/NM;
	}
}
void colorFull64D(){
	double DM[NDITHX][NDITHY];
	int M[NDITHX][NDITHY]={{5,0,3},{2,8,6},{7,4,1}};
	setDitherMat(M, DM, 255);
	int C, R, G, B, RR, GG, BB,D=256/4, R1,R2, G1,G2, B1,B2;
	for(int j=0;j<GHIGHT;j+=NDITHY)for(int i=0;i<GWIDTH;i+=NDITHX){
		for(int x =0; x<NDITHX; x++)for(int y=0;y<NDITHY;y++){
		 	C=pixel(i+x,j+y),R=RED(C), G=GREEN(C), B=BLUE(C);RR=R; GG=G; BB=B;
			R1=R/D*D; R2=R1+D-1;
			G1=G/D*D; G2=G1+D-1;
			B1=B/D*D; B2=B1+D-1;
			R=DTCL(RR,  R2, R1, DM, x, y); 
			G=DTCL(GG,  G2, G1, DM, x, y); 
			B=DTCL(BB,  B2, B1, DM, x, y);
			setPixel(i + x, j + y, RGB(R, G,B));		}
	}
}

【リスト8-10】 カラー用誤差拡散法の共通プログラム
#define NRED   2   // REDの階調数
#define NGREEN 2   // GREENの階調数
#define NBLUE  2   // BLUEの階調数
int red  [GWIDTH][GHIGHT];
int green[GWIDTH][GHIGHT];
int blue [GWIDTH][GHIGHT]; 
void getRGB(){//RGBデータの取り出し
	for(int j=0;j<GHIGHT;j++)for(int i=0; i<GWIDTH;i++){
		int C=pixel(i,j);
		red[i][j]=RED(C);green[i][j]=GREEN(C);blue[i][j]=BLUE (C);
	}
}
int totalDefusion(int Mat[][5]){//拡散テーブルのトータル
	int T=0;
	for(int i=0;i<5;i++)for(int j=0; j<3; j++) T+=Mat[j][i];
	return T;
}
void defusionError(int i, int j, int R, int G, int B, 
					int Mat[][5], int Total){
	for(int k1= 0, ii=i-2; k1<=4; k1++, ii++)
		if(ii>=0 && ii<GWIDTH)//{
		for(int k2= 0, jj=j; k2<=2; k2++, jj++)
			if(Mat[k2][k1]!=0 && jj>=0 && jj<GHIGHT) {
				red  [ii][jj]+=R*Mat[k2][k1]/Total;
	green[ii][jj]+=G*Mat[k2][k1]/Total;
				blue [ii][jj]+=B*Mat[k2][k1]/Total;
			}
}
void defusionProc(int Mat[][5]){//誤差拡散法
	getRGB(); int TT=totalDefusion(Mat), R, G, B;
	int DR=256 / NRED  , XR=255/(NRED   - 1);
	int DG=256 / NGREEN, XG=255/(NGREEN - 1);
	int DB=256 / NBLUE , XB=255/(NBLUE  - 1);
	for(int j=0;j<GHIGHT; j++)for(int i=0;i<GWIDTH; i++){
		R=(red  [i][j]/DR)*XR; R=(R>255)?255:((R<0)?0:R);
		G=(green[i][j]/DG)*XG; G=(G>255)?255:((G<0)?0:G);
		B=(blue [i][j]/DB)*XB; B=(B>255)?255:((B<0)?0:B);
		setPixel(i,j,RGB(R,G,B)); 
		defusionError(i,j, red[i][j]-R, green[i][j]-G, blue[i][j]-B, Mat, TT);
	}
}

【リスト8-11】  Floyd-Steinberg dithering
void Floyd_Steinberg(){
	int Mat[][5]={       // C言語での表記法で
		{0, 0, 0, 7, 0}, // 分かりやすくするため 
		{0, 3, 5, 1, 0}, // XYの添え字を逆転 
		{0, 0, 0, 0, 0}  // しているので注意 
	};
	defusionProc(Mat);
}
void procLButtonDown(HWND hw, WPARAM wp,LPARAM lp){
		Floyd_Steinberg();
	 InvalidateRect(hw,NULL,TRUE);
}

【リスト8-12】  Floyd-Steinberg dithering以外の手法
void False_Floyd_Steinberg(){//いわゆる False Floyd-Steinberg dithering
	int Mat[][5]={
		{0, 0, 0, 3, 0},
		{0, 0, 3, 2, 0},
		{0, 0, 0, 0, 0}
	};
	defusionProc(Mat);
}
void JJN_Algolism(){// Jarvis, Judice, and Ninke dithering
	int Mat[][5]={
		{0, 0, 0, 7, 5},
		{3, 5, 7, 5, 3},
		{1, 3, 5, 3, 1}
	};
	defusionProc(Mat);
}
void Stucki(){
	int Mat[][5]={
		{0, 0, 0, 8, 4},
		{2, 4, 8, 4, 2},
		{1, 2, 4, 2, 1}
	};
	defusionProc(Mat);
}
void Bukes(){
	int Mat[][5]={
		{0, 0, 0, 8, 4},
		{2, 4, 8, 4, 2},
		{0, 0, 0, 0, 0}
	};
	defusionProc(Mat);
}
void Atkinson(){
	int Mat[][5]={
		{0, 0, 0, 1, 1},
		{0, 1, 1, 1, 0},
		{0, 0, 1, 0, 0}
	};
	defusionProc(Mat);
}
void Sierra(){
	int Mat[][5]={
		{0, 0, 0, 5, 3},
		{2, 4, 5, 4, 2},
		{0, 2, 3, 2, 0}
	};
	defusionProc(Mat);
}
void Two_Row_Sierra(){// Two Row Sierra dithering
	int Mat[][5]={
		{0, 0, 0, 4, 3},
		{1, 2, 3, 2, 1},
		{0, 0, 0, 0, 0}
	};
	defusionProc(Mat);
}
void Sierra_Lite(){// Sierra Lite dithering
	int Mat[][5]={
		{0, 0, 0, 2, 0},
		{0, 1, 1, 0, 0},
		{0, 0, 0, 0, 0}
	};
	defusionProc(Mat);
}

【リスト8-13】 カラー無作為ディザリング
#define NRED   2   // REDの階調数
#define NGREEN 2   // GREENの階調数
#define NBLUE  2   // BLUEの階調数
int RDTCL(int X,int MAX, int MIN, int DM){
	return (255*(X-MIN)/(MAX-MIN)>=DM)? MAX:MIN;
}
void colorRandom(){
	int C, R, G, B, RR, GG, BB,R1,R2, G1,G2, B1,B2,DM;
	int DR=256/NRED, DG=256/NGREEN, DB=256/NBLUE;
 	int XR=255/(NRED-1), XG=255/(NGREEN-1), XB=255/(NBLUE-1);
	int RD=255-20, ST=10;srand(1);	
	for(int j=0;j<GHIGHT;j++)for(int i=0;i<GWIDTH;i++){
		DM=(int)(frand()*RD+ST);
		C=pixel(i,j),R=RED(C), G=GREEN(C), B=BLUE(C);RR=R; GG=G; BB=B;
		R1=R2=(R/DR)*XR; if(R>=R1) R2 += XR; else R1 -= XR; 
		G1=G2=(G/DG)*XG; if(G>=G1) G2 += XG; else G1 -= XG; 
		B1=B2=(B/DB)*XB; if(B>=B1) B2 += XB; else B1 -= XB;

		R=RDTCL(RR,  R2, R1, DM); 
		G=RDTCL(GG,  G2, G1, DM); 
		B=RDTCL(BB,  B2, B1, DM);
		setPixel(i, j, RGB(R, G,B));
	}
}