#include "stdafx.h"
#include "TransformAPI.h"
#include <io.h>
#include <errno.h>
#include <math.h>

#include <direct.h>
const int bbp = 4;
// byte per pixel

// calc the start point of the pixel block in DIB
LPSTR WINAPI FindDIBBits(LPSTR lpDIB)
{
	return(lpDIB+*(LPDWORD)lpDIB);
}

// calc the width of the pixel block
DWORD WINAPI DIBWidth(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi=(LPBITMAPINFOHEADER)lpDIB;
	return lpbmi->biWidth;
}


// calc the height of the pixel block
DWORD WINAPI DIBHeight(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi=(LPBITMAPINFOHEADER)lpDIB;
	return lpbmi->biHeight;
}

// perform the GrayImage
BOOL WINAPI GrayImage(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
	unsigned char * lpSrcR; // pointing to red component of a pixel
	unsigned char * lpSrcG;
	unsigned char * lpSrcB;

	BYTE bDst;  // in VC++, BYTE equals unsigned char

	LONG i;
	LONG j;

	// calc the real width of the pixel block in RAM, because when the DIB is put in RAM,
	//the number of bytes of each row must be of times of 4
LONG lLineBytes=WIDTHBYTES(lWidth*bbp*8);

	for(i=0;i<lHeight;i++)  //row
	{
		for(j=0; j<lWidth;j++)  //column
		{
			// Here comes the heart of the program:
			// You'll have to use something like this to access
			// pixel values.
			// This one just changes the current pixel;  the Median Filter below
			// also accesses neighboring pixels.
			lpSrcR=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*bbp;
			lpSrcG=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*bbp+1;
			lpSrcB=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*bbp+2;

			bDst=(*lpSrcR+*lpSrcG+*lpSrcB)/3; // calc the gray color
			*lpSrcR=bDst; //write the gray color back
			*lpSrcG=bDst;
			*lpSrcB=bDst;
		}
	}

	return TRUE;
}
/*
For those using windows XP, the functions must have some small changes.
Because in XP, each pixel occupies 4 bytes (not 3 as above) and r, g, b are in first 3 bytes,
so above code for reading color will be changed as:
LONG lLineBytes=WIDTHBYTES(lWidth*4*8);
lpSrcR=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*4;
lpSrcG=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*4+1;
lpSrcB=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i)+j*4+2;
*/



// simply to say, for each pixel of the image, median filter takes it place with
// the median value of its neighbors
BOOL WINAPI MedianFilter(LPSTR lpDIBBits, LONG lWidth, LONG lHeight,int iFilterW, int iFilterH)
{
	// For Median Filter, need to have 2 images in the RAM
	// one to keep the original image
	// the other to keep the being processed image
	unsigned char * lpSrc; //pointing to a pixel of the original image
	unsigned char * lpDst; //pointing to a pixel of the being processed image

	unsigned char * aR;   // save the red components of the filter window
	unsigned char * aG;
	unsigned char * aB;

    //lpDIB is for original image
	//lpNewDIBBits is the being processed one
	unsigned char * lpNewDIBBits;

	int iPixelX;
	int iPixelY;

	iPixelX=(iFilterW-1)/2;
	iPixelY=(iFilterH-1)/2;

	LONG i,j;
	LONG k,l;
	LONG lLineBytes=WIDTHBYTES(lWidth*bbp*8);


	lpNewDIBBits=new unsigned char[lLineBytes*lHeight];
	memcpy(lpNewDIBBits, lpDIBBits, lLineBytes*lHeight);

    aR=new unsigned char[iFilterH*iFilterW];  //a memory block for red components, say 3*3
	aG=new unsigned char[iFilterH*iFilterW];
	aB=new unsigned char[iFilterH*iFilterW];

    // we have to remove some rows and columns on 4 sides,
	// this because when we calculate the median of a pixel with 9 pixels around it,
	// we are not able to get the 9 neighbors for the pixels on the 4 sides.
	for(i=iPixelY; i<lHeight-iFilterH+iPixelY+1; i++)
	{
		for(j=iPixelX; j<lWidth-iFilterW+iPixelX+1; j++)
		{
			lpDst=(unsigned char *)lpNewDIBBits+lLineBytes*(lHeight-1-i)+j*bbp;

			// for the current pixel, we have to put the red components of its neighbors in aR,
			// greens in aG and blues in aB
			for (k=0; k<iFilterH; k++)
			{
				for(l=0; l<iFilterW; l++)
				{
					// read the 3*3 pixel block around the current pixel(i,j) from the original image
					lpSrc=(unsigned char *)lpDIBBits+lLineBytes*(lHeight-1-i+iPixelY-k)+(j-iPixelX+l)*bbp;
					aR[k*iFilterH+l]=*lpSrc;
					aG[k*iFilterH+l]=*(lpSrc+1);
					aB[k*iFilterH+l]=*(lpSrc+2);
				}
			}

			//now we can calculate the median r, g, and b
			*lpDst=GetMedian(aR,iFilterH*iFilterW); // now put the median color to the being processed image
			*(lpDst+1)=GetMedian(aG, iFilterH*iFilterW);
			*(lpDst+2)=GetMedian(aB, iFilterH*iFilterW);
		}
	}

	memcpy(lpDIBBits, lpNewDIBBits,lLineBytes*lHeight);

	delete [] lpNewDIBBits;
	delete [] aG;
	delete [] aB;
	delete [] aR;
	return true;
}


unsigned char WINAPI GetMax(BYTE * cArray, int iLen)
{

	int i;
	bool bSorted;

	BYTE cTemp;  // in VC++, unsigned char equals BYTE

	// bubble sort
	do
	{
		bSorted=true;
		for (i=0; i<iLen-1; i++)
		{
			if(cArray[i]>cArray[i+1])
			{
				cTemp=cArray[i];
				cArray[i]=cArray[i+1];
				cArray[i+1]=cTemp;

				bSorted=false;
			}
		}

	} while(!bSorted);

	cTemp=cArray[(iLen-1)];

	return cTemp;

}


unsigned char WINAPI GetXDerivative(BYTE * cArray, int iLen, int index)
{

	BYTE cTemp;  // in VC++, unsigned char equals BYTE

	return cTemp=cArray[index];
}

unsigned char WINAPI GetMedian(BYTE * cArray, int iLen)
{

	int i;
	bool bSorted;

	BYTE cTemp;  // in VC++, unsigned char equals BYTE

	// bubble sort
	do
	{
		bSorted=true;
		for (i=0; i<iLen-1; i++)
		{
			if(cArray[i]>cArray[i+1])
			{
				cTemp=cArray[i];
				cArray[i]=cArray[i+1];
				cArray[i+1]=cTemp;

				bSorted=false;
			}
		}

	} while(!bSorted);

	cTemp=cArray[(iLen-1)/2];

	return cTemp;

}