#include"hensu.h"

void amplify(LPDWORD image_in,LPDWORD image_out,double n)
{
	int x,y,nf;

	for(y=0;y<iHeight;y++)
		for(x=0;x<iWidth;x++){
			nf=(int)((BYTE)image_in[x+y*iWidth]*n);
			if(nf>255) nf=255;
			image_out[x+y*iWidth]=RGB(nf,nf,nf);
		}
}

void range(LPDWORD image_in,LPDWORD image_out,int *fmax,int *fmin)
{
	int x,y,nf;

	*fmax=0;
	*fmin=255;
	for(y=0;y<iHeight;y++)
		for(x=0;x<iWidth;x++){
			nf=(BYTE)image_in[x+y*iWidth];
			if(nf>*fmax) *fmax=nf;
			else if(nf<*fmin) *fmin=nf;
		}
}

void expand(LPDWORD image_in,LPDWORD image_out)
{
	int x,y;
	double d;
	int fmax,fmin;

	range(image_in,image_out,&fmax,&fmin);

	for(y=0;y<iHeight;y++)
		for(x=0;x<iWidth;x++){
			d=(double)255/(fmax-fmin)*((BYTE)image_in[x+y*iWidth]-fmin);
			if(d>255) image_out[x+y*iWidth]=255;
			else if(d<0) image_out[x+y*iWidth]=0;
			else image_out[x+y*iWidth]=RGB(d,d,d);
		}
}

typedef struct{
	int x,y;
    unsigned int w;
	unsigned char c;
}DATA,*LPDATA;

unsigned int weight(LPDWORD image_in,int x,int y)
{
	int dim,djm;
	int dip,djp;
	int k,d[8];
	unsigned int wt;

	dim=x-1;
	djm=y-1;
	dip=x+1;
	djp=y+1;
	if(dim<0) dim=x;
	if(djm<0) djm=y;
	if(dip>iWidth-1) dip=x;
	if(djp>iHeight-1) djp=y;

	d[0]=(BYTE)image_in[dim+djm*iWidth];
	d[1]=(BYTE)image_in[x+djm*iWidth];
	d[2]=(BYTE)image_in[dip+djm*iWidth];
	d[3]=(BYTE)image_in[dim+y*iWidth];
	d[4]=(BYTE)image_in[dip+y*iWidth];
	d[5]=(BYTE)image_in[dim+djp*iWidth];
	d[6]=(BYTE)image_in[x+djp*iWidth];
	d[7]=(BYTE)image_in[dip+djp*iWidth];
	
	wt=0;
	for(k=0;k<8;k++)
		wt+=d[k];

	return wt;
}

void quick(LPDATA data,int left,int right)
{
	int i,j;
	unsigned long s;
	DATA temp;

	if(left<right){
		s=(data[(left+right)/2].c<<16)+data[(left+right)/2].w;
		i=left-1; j=right+1;
		while(1){
			while((data[++i].c<<16)+data[i].w>s);
			while((data[--j].c<<16)+data[j].w<s);
			if(i>=j) break;
			temp.x=data[i].x;
			temp.y=data[i].y;
			temp.w=data[i].w;
			temp.c=data[i].c;
			data[i].x=data[j].x;
			data[i].y=data[j].y;
			data[i].w=data[j].w;
			data[i].c=data[j].c;
			data[j].x=temp.x;
			data[j].y=temp.y;
			data[j].w=temp.w;
			data[j].c=temp.c;			
		}
		quick(data,left,i-1);
		quick(data,j+1,right);
	}
}

void plane(LPDWORD image_in,LPDWORD image_out)
{
	int i,j,x,y,av;

	LPDATA data=(LPDATA)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DATA)*iWidth*iHeight);

	for(y=0;y<iHeight;y++)
		for(x=0;x<iWidth;x++){
			data[x+y*iWidth].x=x;
			data[x+y*iWidth].y=y;
			data[x+y*iWidth].w=weight(image_in,x,y);
			data[x+y*iWidth].c=(BYTE)image_in[x+y*iWidth];
		}

	quick(data,0,iWidth*iHeight-1);

	ZeroMemory(image_out,iWidth*iHeight*4);

	av=iWidth*iHeight/256;
	for(i=0;i<256;i++)
		for(j=0;j<av;j++)
			image_out[data[j+i*av].x+data[j+i*av].y*iWidth]=RGB(255-i,255-i,255-i);

	HeapFree(GetProcessHeap(),0,data);
}

void to_color(LPDWORD image_out,LPDWORD image_in,int select_RGB)
{
	int x,y,rgb;

	for(y=0;y<iHeight;y++)
		for(x=0;x<iWidth;x++){
            rgb=(BYTE)image_in[x+y*iWidth];
            switch(select_RGB){
				case 1:
					image_out[x+y*iWidth]=(255<<16)+(rgb<<8)+rgb;
					break;
				case 2:
					image_out[x+y*iWidth]=(rgb<<16)+(255<<8)+rgb;;
					break;
				default:
					image_out[x+y*iWidth]=(rgb<<16)+(rgb<<8)+255;
					break;
			}
		}
}