grabber.c

关于处理图像二值化的程序

/***************************************************************************

	FILE  :  GRABBER.C                   TYP ( PROG/UNIT ) :  UNIT
	 
	AUTOR :   rw
		
	DATE :   02.03.2004
		  
			 Description :
			 - WIN Demo for CANCam
***************************************************************************/
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <time.h>
#include "windem32.h"   
#include "Grabber.h"		
#include "CanCam.h"		


extern char szAppName[];
extern int width,height;
extern BYTE sensor_type, trigger_role, hardware_version, wb;
extern int vPos,hPos;
extern WORD img_cnt;
extern DWORD fpga_mem_offset;
extern BYTE camera;

extern BYTE read_fpga(BYTE cam_nr,WORD reg, DWORD *val);
extern BYTE write_fpga(BYTE cam_nr,WORD reg, DWORD val);

WORD max_pixel[1024];

PBITMAPINFO BitmapInfo;
BYTE *Prgb;	


BOOL initcancam(HWND hWnd,char *ip, WORD port)
{
   BOOL    ret = TRUE;
	HCURSOR OldCursor;
	BYTE    error;
	char e_str[150],ss[20];
	WORD x1,x2,y1,y2;
	
	OldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
	set_status_bar(0,"Init CanCam .......");
	
	error = init_cancam(camera,ip,port);				//Init CANCam
	if(error)
	{
		sprintf(e_str,"Failure initializing CanCam ERROR-NR. %d",error);
		MessageBox(NULL,e_str,szAppName,MB_OK | MB_ICONSTOP);
		ret = FALSE;
		sprintf(e_str,"%s",szAppName);
	}
	else
	{
		x1 = (1288/2) - (1280/2);
		x2 = (1288/2) + (1280/2) - 1;
		y1 = (1024/2) - (1024/2);
		y2 = (1024/2) + (1024/2) - 1;

		error = set_video_window(camera,x1,y1,x2,y2);
		if(error)
		{
		sprintf(e_str,"Failure setting video window ERROR-NR. %d",error);
		MessageBox(NULL,e_str,szAppName,MB_OK | MB_ICONSTOP);
		ret = FALSE;
		sprintf(e_str,"%s",szAppName);
		}
		get_sensor_type(camera,&sensor_type, &trigger_role);
		get_hardware_version(camera,&hardware_version);
		switch (sensor_type)
		{
		case 0:
			switch (trigger_role)
			{
				case 0:	strcpy(ss,"LM9638 Master-V");break;
				case 1: strcpy(ss,"LM9638 Slave I-V");break;
				case 2: strcpy(ss,"LM9638 Slave E-V"); break;
				default:strcpy(ss,"LM9638 ??-V"); break;
			}
			break;

		case 1:
			switch (trigger_role)
			{
				case 0:	strcpy(ss,"LM9648 Master-V");break;
				case 1: strcpy(ss,"LM9648 Slave I-V");break;
				case 2: strcpy(ss,"LM9648 Slave E-V"); break;
				default:strcpy(ss,"LM9648 ??-V"); break;
			}
			break;
		case 9:
			strcpy(ss,"Grabber-V");
			break;

		default:
			strcpy(ss,"??");
			break;
		}
		
		sprintf(e_str,"%s - %s%d",szAppName,ss,hardware_version);
	}
	
	
	SetWindowText(hWnd, e_str);
	set_status_bar(0,"");
	SetCursor(OldCursor);
	
	return ret;
}



HPALETTE SetBMPPalette(HDC hDC,HWND hWnd, HPALETTE *hPal)
{
	
	int	  i,wNumColors;
	LPLOGPALETTE     lpPal;
	HANDLE           hLogPal;
	HPALETTE	  OldPal=NULL;
	
	wNumColors=256;
	
	hLogPal = GlobalAlloc (GHND, sizeof (LOGPALETTE) +
		sizeof (PALETTEENTRY) * wNumColors);
	
	lpPal = (LPLOGPALETTE) GlobalLock (hLogPal);
	
	lpPal->palVersion    = 0x300;
	lpPal->palNumEntries = wNumColors;
	
	for (i = 0;  i < wNumColors;  i++)
	{
		lpPal->palPalEntry[i].peRed   = i;
		lpPal->palPalEntry[i].peGreen = i;
		lpPal->palPalEntry[i].peBlue  = i;
		lpPal->palPalEntry[i].peFlags = 0;
	}
	
	*hPal = CreatePalette (lpPal);
	
	if (!*hPal)
	{
		MessageBox(hWnd, "Create palette failure.", szAppName,
			MB_OK | MB_ICONSTOP);
		return(OldPal);
	}
	
	OldPal = SelectPalette(hDC, *hPal, 0);
	RealizePalette(hDC);
	
	GlobalUnlock (hLogPal);
	GlobalFree   (hLogPal);
	
	return(OldPal);
}


GLOBALHANDLE create_bitmap_header(void)
{
	int i;
	LPSTR pLookUp;
	GLOBALHANDLE hBitmap_Info;
	int isize; 

	width  = 1280;
	height = 1024;
	
	isize = (width * (int)3) * height;
	hBitmap_Info = GlobalAlloc(GHND, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD) + isize);
	if(hBitmap_Info)
	{
		BitmapInfo = (PBITMAPINFO) GlobalLock(hBitmap_Info);
		BitmapInfo->bmiHeader.biSize = (long) sizeof(BITMAPINFOHEADER);
		BitmapInfo->bmiHeader.biWidth = 1280;
		BitmapInfo->bmiHeader.biHeight = 1024;
		BitmapInfo->bmiHeader.biPlanes = 1;
		BitmapInfo->bmiHeader.biBitCount = 8;
		BitmapInfo->bmiHeader.biSizeImage = ((DWORD)BitmapInfo->bmiHeader.biWidth *	(DWORD)BitmapInfo->bmiHeader.biHeight);
		BitmapInfo->bmiHeader.biXPelsPerMeter = 0;
		BitmapInfo->bmiHeader.biYPelsPerMeter = 0;
		BitmapInfo->bmiHeader.biClrUsed = 256;
		BitmapInfo->bmiHeader.biClrImportant = 256;
		
		pLookUp = (LPSTR)BitmapInfo->bmiColors;
		for (i=0; i<256; i++)
		{
			*pLookUp++ = (BYTE)i;
			*pLookUp++ = (BYTE)i;
			*pLookUp++ = (BYTE)i;
			*pLookUp++ = 0;
		}

		Prgb = (BYTE *)BitmapInfo + sizeof(BITMAPINFOHEADER) + (int)256 * sizeof(RGBQUAD);
		return(hBitmap_Info);
	}
	return(NULL);
}


PBITMAPINFO get_bitmap_info(void)
{
	return(BitmapInfo);
}

void make_rgb(BYTE *rgb,BYTE *cfa[],BYTE *red[], BYTE *green[], BYTE *blue[])
{
	int x,y,cnt_green=0, cnt_red=0, cnt_blue=0;
	BYTE c;
	BYTE *phelp;
	BYTE *r,*g,*b;
	FILE *hfile;
	int i,j;
	char l_str[30],s_str[10000];
	DWORD c_green=0, c_red=0, c_blue=0;
	float wb_red, wb_blue, avg_green, avg_red, avg_blue;

  // replicate pixels from the initial buffer into 
  // red, blue and green matrices...               

	
/*	if ((hfile = fopen("pixvalue.txt","wt" )) != NULL)
	{
		for(i = 0;i < 1024;i++)
		{
			sprintf(l_str,"Zeile %4d:",i);
			fwrite(l_str,strlen(l_str),1,hfile);
			s_str[0] = '\0';
			for(j = 0;j < 1280;j++)
			{
				sprintf(l_str,"%x:",*(cfa[i]+j));
				strcat(s_str,l_str);
			}
			fwrite(s_str,strlen(s_str),1,hfile);
			sprintf(l_str,"\n");
			fwrite(l_str,strlen(l_str),1,hfile);
		}

		fclose(hfile);
	}
*/
/*	if ((hfile = fopen("pixvalue.dat","wb" )) != NULL)
	{
		for(i = 0;i < 1024;i++)
			fwrite(cfa[i],1280,1,hfile);
		fclose(hfile);
	}
*/


	
	for( y = 0; y < height; y += 2 )
    {
        for( x = 0; x < width; x += 2 )
        {
            // grGRgrGR  :=  ggGGggGG  rrRRrrRR  bbBBbbBB 
            // bgBGbgBG  :=  ggGGggGG  rrRRrrRR  bbBBbbBB 
            // GRGRGRGR  :=  ...                          
				c = *(cfa[y] + x);
            *(green[y] + x)     = c;//*(cfa[y] + x);
            *(green[y] + x+1)   = c;//*(cfa[y] + x);
			c_green += c;
			cnt_green++;

				c = *(cfa[y+1] + x+1);
            *(green[y+1] + x)   = c;//*(cfa[y+1] + x+1);
            *(green[y+1] + x+1) = c;//*(cfa[y+1] + x+1);
			c_green += c;
			cnt_green++;

				c = *(cfa[y] + x+1);
            *(red[y] + x) = c;
            *(red[y] + x+1) = c;
            *(red[y+1] + x) = c;
            *(red[y+1] + x+1) = c;
			c_red += c;
			cnt_red++;

				c = *(cfa[y+1] + x);
            *(blue[y] + x) = c;
            *(blue[y] + x+1) = c;
            *(blue[y+1] + x) = c;
            *(blue[y+1] + x+1) = c;
			c_blue += c;
			cnt_blue++;
        }
    }

	avg_green = ((float)c_green/cnt_green);		//get average of green
	avg_red = ((float)c_red/cnt_red);			//get average of red
	avg_blue = ((float)c_blue/cnt_blue);		//get average if blue
	
	wb_blue = (float)avg_blue/(float)avg_green; //calculate white balancing factor for blue
	wb_red = (float)avg_red/(float)avg_green;	//calculate white balancing factor for red

	// compute the interpolated red data 

    for ( y = 2; y < height-2; y += 2 )
    {
        for ( x = 3; x < width-2; x += 2 )
        {
            // get the left, bottom, corner red pixels 

            unsigned char r, rl, rb, rc;

            r  = *(cfa[y] + x);
            rl = *(cfa[y] + x-2);
            rb = *(cfa[y+2] + x);
            rc = *(cfa[y+2] + x-2);

            *(red[y] + x-1)   = (r + rl          ) / 2;
            *(red[y+1] + x)   = (r      + rb     ) / 2;
            *(red[y+1] + x-1) = (r + rl + rb + rc) / 4;
        }
    }



	  // compute the interpolated green data 

    for ( y = 2; y < height-2; y += 2 )
    {
        for ( x = 3; x < width-2; x += 2 )
        {
            // get the left, right, top, bottom green pixels 

            unsigned char gl, gr, gt, gb;

            gl = *(cfa[y] + x-1);
            gr = *(cfa[y] + x+1);
            gt = *(cfa[y-1] + x);
            gb = *(cfa[y+1] + x);

            *(green[y] + x) = (gl + gr + gt + gb) / 4;
        }
    }

    for ( y = 3; y < height-2; y += 2 )
    {
        for ( x = 2; x < width-2; x += 2 )
        {
            // get the left, right, top, bottom green pixels 

            unsigned char gl, gr, gt, gb;

            gl = *(cfa[y] + x-1);
            gr = *(cfa[y] + x+1);
            gt = *(cfa[y-1] + x);
            gb = *(cfa[y+1] + x);
      
            *(green[y] + x) = (gl + gr + gt + gb) / 4;
        }
    }


   for ( y = 3; y < height-2; y += 2 )
    {
        for ( x = 2; x < width-2; x += 2 )
        {
            // get the right, top, corner blue pixels 
			   unsigned char b, br, bt, bc;

            b  = *(cfa[y] + x);
            br = *(cfa[y] + x+2);
            bt = *(cfa[y-2] + x);
            bc = *(cfa[y-2] + x+2);

            *(blue[y] + x+1) = (b + br            ) / 2;
            *(blue[y-1] + x) = (b        + bt     ) / 2;
            *(blue[y-1] + x+1) = (b + br + bt + bc) / 4;
        }
    }

	phelp = rgb;
	r = red[0];
	g = green[0];
	b = blue[0];

	for( y = 0; y < height; y++)
    {
        for( x = 0; x < width; x++)
        {
			   
			if(wb)
			{
				*phelp++ = (BYTE)((*b++ /wb_blue));	// adjust blue