imageobjectdlg.cpp.bak

实时视频捕获

	{
		m_SysSetPara.detect_num=3;
		m_SysSetPara.image_contrast=50;
		m_SysSetPara.image_light=50;
		for(int i=0;i<6;i++)
		{
			m_SysSetPara.dtr[i].region.top=100+70*i;
			m_SysSetPara.dtr[i].region.bottom=100+70*i+25;
			m_SysSetPara.dtr[i].region.left=500;
			m_SysSetPara.dtr[i].region.right=600;
			m_SysSetPara.dtr[i].threshold=180;
		}
		this->SaveParameter();
	}
	fclose(fp);
	return true;
}
bool CImageObjectDlg::SaveParameter()
{
	FILE * fp;
	char szFileName[20];
	//保存参数到文件
	sprintf(szFileName, "c:\\detectconfig.cfg");
	fp = fopen(szFileName, "wb");
	if(!fp)	return false;
	fwrite(&m_SysSetPara, sizeof(SystemSetParameter), 1, fp);
	fclose(fp);
	return true;
}
bool CImageObjectDlg::InitVideoCaptureCard()
{
	HRESULT hr;
	BOOL bConnectOk;
	VIDEOSTREAMINFO vsi;
	bool result=TRUE;
	VIDEOPROPERTYRANGE *pVPR=new VIDEOPROPERTYRANGE;
	int devicenum;
	DSStream_GetCardNumber(&devicenum);
	hr = DSStream_IsConnected(m_CardID, &bConnectOk);
	if(FAILED(hr) || bConnectOk)
	{
//		DSStream_DisconnectDevice(m_CardID);
		m_CardID++;
		hr = DSStream_IsConnected(m_CardID, &bConnectOk);
		if(FAILED(hr) ||bConnectOk)
		{
			AfxMessageBox(_T(" 无可用的卡"), MB_OK|MB_ICONSTOP, 0);
			return false;
		}
	}
	if(FAILED(hr) || bConnectOk)
	{
		AfxMessageBox(_T(" 连接失败"), MB_OK|MB_ICONSTOP, 0);
		return false;
	}
	hr = DSStream_ConnectDevice(m_CardID, FALSE);

	hr = DSStream_IsConnected(m_CardID, &bConnectOk);
	if(FAILED(hr) || !bConnectOk)
		return false;
	//创建视频预览窗口
	CRuntimeClass   *pRunTimeClass=RUNTIME_CLASS(CChildFrame); 
	m_lpShowVideoWnd=(CChildFrame*)pRunTimeClass-> CreateObject(); 
	CREATESTRUCT   cs; 
	cs.lpszClass=0; 
	m_lpShowVideoWnd-> PreCreateWindow(cs); 
	WNDCLASS   wcl; 
	GetClassInfo(AfxGetInstanceHandle(),cs.lpszClass,&wcl); 
	wcl.lpszClassName=_T( "my  class "); 
	wcl.hbrBackground=HBRUSH(6); 
	::RegisterClass(&wcl); 
	m_lpShowVideoWnd->CreateEx(NULL,wcl.lpszClassName, 
				_T("我的窗口"),WS_OVERLAPPED|WS_OVERLAPPEDWINDOW, 
				CRect(100,100,300,300),this,NULL,NULL); 
	//	CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName, LPCTSTR  lpszWindowName,
	//  DWORD dwStyle, const RECT& rect, CWnd* pParentWnd,   
	//  UINT nID, LPVOID lpParam= NULL); 
//	m_lpShowVideoWnd->SetOwner(this);
	m_lpShowVideoWnd-> ShowWindow(SW_SHOW); //SW_HIDE SW_SHOW
	m_lpShowVideoWnd-> UpdateWindow();
	m_lpShowVideoWnd->m_iCardID=m_CardID;
	m_lpShowVideoWnd->m_bOverlay=FALSE;

	DSStream_SetOwnerWnd(m_CardID, m_lpShowVideoWnd->m_hWnd);
	DSStream_SetMessageDrain(m_CardID, m_lpShowVideoWnd->m_hWnd);
	DSStream_SetNotifyWindow(m_CardID, m_lpShowVideoWnd->m_hWnd, UM_VIDEO_ERROR_NOTIFY);
	//设置视频制式
	DSStream_SetVideoStandard(m_CardID, VideoStandard_PAL_B);
	//设置视频源
	DSStream_RouteInPinToOutPin(m_CardID, PREVIEW, 0);
	//设置视频属性：亮度、对比度、色度、饱和度
	DSStream_SetVideoPropertyValue(m_CardID, VideoProperty_Hue,5000);
	DSStream_SetVideoPropertyValue(m_CardID, VideoProperty_Saturation, 5000);
	DSStream_GetVideoPropertyValue(m_CardID, VideoProperty_Brightness,pVPR );
	long temp;
	if(SUCCEEDED(hr))
	{
		m_lBrightMin=pVPR->lMin;
		m_lBrightMax=pVPR->lMax;
		m_lBrightStep=pVPR->lStepDelta;
		temp=m_SysSetPara.image_light*(m_lBrightMax-m_lBrightMin)/100+m_lBrightMin;
		hr=DSStream_SetVideoPropertyValue(m_CardID, VideoProperty_Brightness,temp );
	}

	hr=DSStream_GetVideoPropertyValue(m_CardID, VideoProperty_Contrast,pVPR );
	if(SUCCEEDED(hr))
	{
		m_lContrastMin=pVPR->lMin;
		m_lContrastMax=pVPR->lMax;
		m_lContrastStep=pVPR->lStepDelta;
		temp=m_SysSetPara.image_contrast*(m_lContrastMax-m_lContrastMin)/100+m_lContrastMin;
		hr=DSStream_SetVideoPropertyValue(m_CardID, VideoProperty_Contrast,temp );
	
	}

	//设置视频格式：视频格式、宽、高
//	DSStream_RouteInPinToOutPin(m_CardID,PREVIEW,0);//CAPTURE);//PREVIEW

	DSStream_GetVideoInfo(m_CardID, &vsi, PREVIEW);//PREVIEW);CAPTURE
	vsi.subtype = VideoSubType_RGB24;
	vsi.bmiHeader.biWidth= IMAGE_WIDTH;
	vsi.bmiHeader.biHeight=IMAGE_HEIGHT;
	vsi.AvgTimePerFrame=10000000/2;
	DSStream_DisconnectPin(m_CardID, PREVIEW);//CAPTURE);//PREVIEW
	hr=DSStream_SetVideoInfo(m_CardID, vsi,  PREVIEW);//CAPTURE);// 
	DSStream_ConnectPin(m_CardID, PREVIEW);//CAPTURE);//PREVIEW
	
//	DSStream_RouteInPinToOutPin(m_CardID,CAPTURE,0);//CAPTURE);//PREVIEW
/*
	DSStream_GetVideoInfo(m_CardID, &vsi, CAPTURE);//PREVIEW);CAPTURE
	vsi.subtype = VideoSubType_RGB24;
	vsi.bmiHeader.biWidth= IMAGE_WIDTH;
	vsi.bmiHeader.biHeight=IMAGE_HEIGHT;
	vsi.AvgTimePerFrame=10000000/5;
	DSStream_DisconnectPin(m_CardID, CAPTURE);//CAPTURE);//PREVIEW
	hr=DSStream_SetVideoInfo(m_CardID, vsi,  CAPTURE);//CAPTURE);// 
	DSStream_ConnectPin(m_CardID, CAPTURE);//CAPTURE);//PREVIEW
*/
//	DSStream_RouteInPinToOutPin(m_CardID,CAPTURE,0);//CAPTURE);//PREVIEW
	DSStream_GetVideoStream(m_CardID, VideoStreamCallbak,this);

//	DSStream_GetVideoInfo(m_CardID, &vsi,  CAPTURE);//CAPTURE);//PREVIEW
	int status;
	hr=DSStream_GetStreamStatus(m_CardID,&status);
	if(SUCCEEDED(hr)&&(status!=RUN))
	{
		DSStream_SetStreamStatus(m_CardID,RUN);
	}
	return result;
}
LRESULT CImageObjectDlg::ImageProcess(  WPARAM wParam, LPARAM lParam)
{
	CRect showrect(0,0,0,0);
//	m_bmpMain.GetBitmapBits(m_lpbmiVideo->bmiHeader.biSizeImage,m_bufferVideo);

//	m_ShowImage.GetWindowRect(showrect);
//	CClientDC dc(FromHandle(m_ShowImage.m_hWnd));
//	CDC *dc=GetDC();
//	::SetDIBitsToDevice(dc.m_hDC,0 ,0 ,IMAGE_WIDTH,IMAGE_HEIGHT,0,0,0,m_lpbmiVideo->bmiHeader.biHeight,m_bufferVideo,m_lpbmiVideo,DIB_RGB_COLORS);//m_bufferVideo  lpcallbakdata
//	dc.SelectObject(&m_bmpMain);
//	dc.StretchBlt(0,0,IMAGE_WIDTH,IMAGE_HEIGHT,&dc,0,0,m_lpbmiVideo->bmiHeader.biWidth,m_lpbmiVideo->bmiHeader.biHeight,SRCCOPY);
//	::StretchDIBits(dc.m_hDC,0 ,0 ,IMAGE_WIDTH,IMAGE_HEIGHT,0,0,m_lpbmiVideo->bmiHeader.biWidth,m_lpbmiVideo->bmiHeader.biHeight,lpcallbakdata,m_lpbmiVideo,DIB_RGB_COLORS,SRCCOPY);
//	ReleaseDC(dc);
	
//	m_bmpMain.GetBitmapBits(IMAGE_WIDTH*IMAGE_HEIGHT*3,m_bufferVideo);
	
	GetRegionImageData();
	for(int i=0;i<m_SysSetPara.detect_num;i++)
	{
		RegionImageProcess(i);
	}
/*
	FILE *lpfile=fopen("d:\\readbak.bin", "w");
	fwrite(m_bufferVideo,1,m_lpbmiVideo->bmiHeader.biSizeImage,lpfile);
		fclose(lpfile);
*/
	DisplayResult();

	return 0; 
}

void CImageObjectDlg::RegionImageProcess(int region_id)
{
	if(region_id<=0||region_id>=MAX_DETECT_REGION_NUM)
		return;
	int statu=m_iRegionDetectStatu[region_id];//NO_OBJECT,BEGIN,MIDDLE,END
	int threshold=this->m_SysSetPara.dtr[region_id].threshold;
	int wx=m_SysSetPara.dtr[region_id].region.Width();
	int wy=m_SysSetPara.dtr[region_id].region.Height();
	BYTE *bin=new BYTE[wx];
	AverageFilter1D(m_VAverageLight[region_id],wx,11);
	BinTranslate(m_VAverageLight[region_id],bin,wx,threshold);
	switch(statu)
	{
		case NO_OBJECT:
			if(CheckHeader(bin,wx,threshold))m_iRegionDetectStatu[region_id]=OBJECT_HEAD;
			break;
		case OBJECT_HEAD:
			if(CheckBody(bin,wx,threshold))m_iRegionDetectStatu[region_id]=OBJECT_MIDDLE;
			break;
		case OBJECT_MIDDLE:
			if(CheckEnd(bin,wx,threshold))
			{
				m_iRegionDetectStatu[region_id]=OBJECT_TAIL;
				m_iDetectCountTotal++;
				m_iDetectCountTemp++;
				CFile fileDeliver;
				if(fileDeliver.Open(_T("C:\\"),CFile::modeReadWrite |CFile::osWriteThrough,NULL))
				{
					char *buffer=new char[20];
					int k;
					int readnum=fileDeliver.Read(buffer,20);
					if(readnum)
					{
						k=atoi(buffer);
						k+=m_iDetectCountTemp;
					}else
					{
						k=0;
					}
					_itoa(k,buffer,10);
					fileDeliver.SeekToBegin();
					fileDeliver.Write(buffer,20);
					fileDeliver.Close();
					m_iDetectCountTemp=0;
					delete buffer;
				}
			}	
			break;
		case OBJECT_TAIL:
			if(CheckHeader(bin,wx,threshold))
			{
				m_iRegionDetectStatu[region_id]=OBJECT_HEAD;
			}else
			{
				m_iRegionDetectStatu[region_id]=NO_OBJECT;
			}
			break;
		default: 
			statu=NO_OBJECT;
			break;
	}
	m_CurveSpeed++;
	for(int i=0;i<m_SysSetPara.detect_num;i++)
	{
		m_CurveAverage[i]+=m_BrightnessAverage[i];
	}
	if(m_CurveSpeed>=BRIGHT_CURVE_SPEED)
	{
		for(int i=0;i<m_SysSetPara.detect_num;i++)
		{
			m_RegionLightHist[i][m_indexofLightHist]=m_CurveAverage[i]/BRIGHT_CURVE_SPEED;
			m_CurveAverage[i]=0;
		}
		m_indexofLightHist++;
		m_indexofLightHist=m_indexofLightHist%100;
	}
	delete bin;
}
void CImageObjectDlg::BinTranslate(BYTE *processData,BYTE *result,long size,int threshold)
{
	for(long i=0;i<size;i++)
	{
		(processData[i]>threshold)?result[i]=255:result[i]=0;
	}
}
void CImageObjectDlg::AverageFilter1D(BYTE *processData,long size,int windowSize)
{
	if(windowSize<3)return;
	if(size<=windowSize)return;
	if(processData==NULL)return;
	long i;
	long value;
	BYTE *buffer=new BYTE[size];
	memcpy(buffer,processData,size);
	for(i=windowSize/2;i<size-(windowSize-1)/2;i++)
	{
		value=0;
		for(int j=-windowSize/2;j<(windowSize+1)/2;j++)
		{
			value+=buffer[i+j];
		}
		value=value/windowSize;
		if(value>255)value=255;
		processData[i]=(BYTE)value;
	}
	delete buffer;
}
void CImageObjectDlg::MiddleFilter1D(BYTE *processData,long size,int windowSize)
{
	if(windowSize<3)return;
	if(size<=windowSize)return;
	if(processData==NULL)return;
	BYTE * temp= new BYTE [size];
	BYTE * newbuf= new BYTE [windowSize];
	BYTE mid_value;
	long i;
	int k;
	memcpy(temp,processData,size);
	for(i=windowSize/2;i<size-(windowSize-1)/2;i++)
	{
		k=0;
		for(int j=-windowSize/2;j<(windowSize+1)/2;j++)
		{
			newbuf[k++]=temp[i+j];
		}
		for(int m=0;m<windowSize;m++)
		{
			for(int n=0;n<windowSize-m;n++)
			{
				if(newbuf[n]>newbuf[n+1]) 
				{	
					mid_value = newbuf[n];
					newbuf[n]=newbuf[n+1];
					newbuf[n+1]= mid_value;
				}
			}
		}
		processData[i]=newbuf[windowSize/2];
	}
	delete temp;
	delete newbuf;
}
bool CImageObjectDlg::CheckHeader(BYTE *processData,long size,int threshold)
{
	int white=0;
	int width_trig=20;
	for(int i=0;i<width_trig;i++)
	{
		if(processData[size-1-i]>threshold)white++;
	}
	if(white>width_trig-3)
	{
		return TRUE;
	}else
	{
		return FALSE;
	}
}
bool CImageObjectDlg::CheckBody(BYTE *processData,long size,int threshold)
{
	int white=0;
	int width_trig=20;
	for(int i=0;i<size;i++)
	{
		if(processData[size-1-i]>threshold)white++;
	}
	if(white>size-5)
	{
		return TRUE;
	}else
	{
		return FALSE;
	}
}
bool CImageObjectDlg::CheckEnd(BYTE *processData,long size,int threshold)
{
	int black=0;
	int width_trig=20;
	int i;
	for( i=0;i<size;i++)
	{
		if(processData[size-1-i]<threshold)break;
	}
	if(i<(size*0.8))
	{
		for(;i<size;i++)
		{
			if(processData[size-1-i]<threshold)
			{