?? 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 )
{
// 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
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -