void detect_object(IplImage *image, IplImage *pBkImg, IplImage *pFrImg, CvMat *pFrameMat, CvMat *pBkMat, CvMat *pFrMat,int thre_limit)
{
nFrmNum++;
cvCvtColor(image, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//高斯滤波
cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//当前帧减去背景图像并取绝对值
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//二值化前景图像
cvThreshold(pFrMat, pFrImg,thre_limit, 255.0, CV_THRESH_BINARY);
/*形态学滤波*/
//IplConvKernel* element = cvCreateStructuringElementEx(2, 2, 0, 0, CV_SHAPE_RECT);
//cvErode(pFrImg, pFrImg,element, 1); // 腐蚀
//delete element;
//element = cvCreateStructuringElementEx(2, 2, 1, 1, CV_SHAPE_RECT);
//cvDilate(pFrImg, pFrImg, element, 1); //膨胀
//delete element;
cvErode(pFrImg, pFrImg,0, 1); // 腐蚀
cvDilate(pFrImg, pFrImg,0, 1); //膨胀
//滑动平均更新背景（求平均）
cvRunningAvg(pFrameMat, pBkMat, 0.004, 0);
//将背景矩阵转化为图像格式，用以显示
cvConvert(pBkMat, pBkImg);
cvShowImage("background", pFrImg);
// cvShowImage("background", pBkImg);
}
void MainWindow::BackgroundDiff()
{
ui->alpha_slider->setEnabled(true);
cvReleaseCapture(&pCapture);
pCapture=cvCaptureFromCAM(0);
// IplImage* pFrame=NULL;
nFrameNum=0;
while(pFrame = cvQueryFrame( pCapture ))
{
nFrameNum++;
//如果是第一帧，需要申请内存，并初始化
if(nFrameNum == 1)
{
pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),IPL_DEPTH_8U,1);
pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//转化成单通道图像再处理
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
cvConvert(pFrImg, pFrMat);
cvConvert(pFrImg, pBkMat);
}
else
{
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//先做高斯滤波，以平滑图像
cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//当前帧跟背景图相减
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//二值化前景图
cvDilate(pFrMat,pFrMat);
cvErode(pFrMat,pFrMat);
cvThreshold(pFrMat, pFrImg, lowThreshold, 255.0, CV_THRESH_BINARY);
//更新背景
cvRunningAvg(pFrameMat, pBkMat, alpha,0);
//将背景转化为图像格式，用以显示
cvConvert(pBkMat, pBkImg);
pFrame->origin = IPL_ORIGIN_BL;
pFrImg->origin = IPL_ORIGIN_BL;
pBkImg->origin = IPL_ORIGIN_BL;
}
if(27==cvWaitKey(33))
break;
MainWindow::Display(pFrame,pBkImg,pFrImg);
}
}
void BlinkDetector::update(const boost::scoped_ptr<IplImage> &eyeFloat) {
if (!_initialized) {
cvCopy(eyeFloat.get(), _averageEye.get());
_initialized = true;
}
double distance = cvNorm(eyeFloat.get(), _averageEye.get(), CV_L2);
_accumulator.update(distance);
//cout << "update distance" << distance << " -> " << accumulator.getValue() << endl;
_states.updateState(distance / _accumulator.getValue());
cvRunningAvg(eyeFloat.get(), _averageEye.get(), 0.05);
}
int main() {
IplImage *frame, *accumulator=NULL;
cv_dc1394_init();
while (cv_sdl_process_events()) {
frame = cv_dc1394_capture_yuv(1)[0];
if (!accumulator)
accumulator = cvCreateImage(cvGetSize(frame), 32, 3);
cvRunningAvg(frame, accumulator, 0.1);
cvConvert(accumulator, frame);
cv_sdl_show_yuv_image(frame);
}
}
//由于高斯背景建模没返回背景，所以使用平均背景法自动生成背景
bool GetAvgBackgroudImg(const IplImage *pFrame, IplImage *bgImg,double alpha)
{
static bool isFirst=true;
static IplImage *pAccImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_32F,3);
if(isFirst){
cvSetZero(pAccImg);
isFirst=false;
}
if (!pFrame || !bgImg || !pAccImg ||
pAccImg->width != pFrame->width || pAccImg->width != bgImg->width ||
pAccImg->height != pFrame->height || pAccImg->height != bgImg->height||
pFrame->nChannels!=3 || pFrame->nChannels!=3){
return false;
}
cvRunningAvg(pFrame,pAccImg,alpha);
cvConvertScale(pAccImg,bgImg,1.,0.);
return true;
}
int diff2_main( int argc, char** argv )
{
//声明IplImage指针
IplImage* pFrame = NULL;
IplImage* pFrImg = NULL;
IplImage* pBkImg = NULL;
CvMat* pFrameMat = NULL;
CvMat* pFrMat = NULL;
CvMat* pBkMat = NULL;
CvCapture* pCapture = NULL;
int nFrmNum = 0;
//创建窗口
cvNamedWindow("video", 1);
cvNamedWindow("background",1);
cvNamedWindow("foreground",1);
//使窗口有序排列
cvMoveWindow("video", 30, 0);
cvMoveWindow("background", 360, 0);
cvMoveWindow("foreground", 690, 0);
if( !(pCapture = cvCaptureFromAVI("bike.avi")))
{
//pCapture = cvCaptureFromCAM(-1))
fprintf(stderr, "Can not open camera.\n");
return -2;
}
//逐帧读取视频
while(pFrame = cvQueryFrame( pCapture ))
{
nFrmNum++;
//如果是第一帧，需要申请内存，并初始化
if(nFrmNum == 1)
{
pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//转化成单通道图像再处理
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
cvConvert(pFrImg, pFrMat);
cvConvert(pFrImg, pBkMat);
}
else
{
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//高斯滤波先，以平滑图像
//cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//当前帧跟背景图相减
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//二值化前景图
cvThreshold(pFrMat, pFrImg, 60, 255.0, CV_THRESH_BINARY);
//进行形态学滤波，去掉噪音
//cvErode(pFrImg, pFrImg, 0, 1);
//cvDilate(pFrImg, pFrImg, 0, 1);
//更新背景
cvRunningAvg(pFrameMat, pBkMat, 0.003, 0);
//将背景转化为图像格式，用以显示
cvConvert(pBkMat, pBkImg);
//显示图像
cvShowImage("video", pFrame);
cvShowImage("background", pBkImg);
cvShowImage("foreground", pFrImg);
//如果有按键事件，则跳出循环
//此等待也为cvShowImage函数提供时间完成显示
//等待时间可以根据CPU速度调整
if( cvWaitKey(20) >= 0 )
{
break;
}
}
}
cvWaitKey();
//销毁窗口
cvDestroyWindow("video");
cvDestroyWindow("background");
cvDestroyWindow("foreground");
//释放图像和矩阵
cvReleaseImage(&pFrImg);
cvReleaseImage(&pBkImg);
cvReleaseMat(&pFrameMat);
cvReleaseMat(&pFrMat);
cvReleaseMat(&pBkMat);
cvReleaseCapture(&pCapture);
return 0;
}
int main( int argc, char** argv )
{
const char avi_name[]="..\\res\\de.avi";
//聲明IplImage指針
IplImage* pFrame = NULL;
IplImage* pFrImg = NULL;
IplImage* pBkImg = NULL;
CvMat* pFrameMat = NULL;
CvMat* pFrMat = NULL;
CvMat* pBkMat = NULL;
CvCapture* pCapture = NULL;
int nFrmNum = 0;
//創建視窗
cvNamedWindow("video", 1);
cvNamedWindow("background",1);
cvNamedWindow("foreground",1);
//使視窗有序排列
cvMoveWindow("video", 30, 0);
cvMoveWindow("background", 360, 0);
cvMoveWindow("foreground", 690, 0);
if( argc > 2 )
{
fprintf(stderr, "Usage: bkgrd [video_file_name]\n");
return -1;
}
//打開攝像頭
if (argc ==1)
if( !(pCapture = cvCaptureFromAVI(avi_name)))
{
fprintf(stderr, "Can not open camera.\n");
return -2;
}
//打開視頻文件
if(argc == 2)
if( !(pCapture = cvCaptureFromFile(argv[1])))
{
fprintf(stderr, "Can not open video file %s\n", argv[1]);
return -2;
}
//逐幀讀取視頻
while(pFrame = cvQueryFrame( pCapture ))
{
nFrmNum++;
//如果是第一幀，需要申請記憶體，並初始化
if(nFrmNum == 1)
{
pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//轉化成單通道圖像再處理
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
cvConvert(pFrImg, pFrMat);
cvConvert(pFrImg, pBkMat);
}
else
{
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//高斯濾波先，以平滑圖像
//cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//當前幀跟背景圖相減
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//二值化前景圖
cvThreshold(pFrMat, pFrImg, 60, 255.0, CV_THRESH_BINARY);
//進行形態學濾波，去掉噪音
//cvErode(pFrImg, pFrImg, 0, 1);
//cvDilate(pFrImg, pFrImg, 0, 1);
//更新背景
cvRunningAvg(pFrameMat, pBkMat, 0.003, 0);
//將背景轉化為圖像格式，用以顯示
cvConvert(pBkMat, pBkImg);
//顯示圖像
cvShowImage("video", pFrame);
cvShowImage("background", pBkImg);
cvShowImage("foreground", pFrImg);
//如果有按鍵事件，則跳出迴圈
//此等待也為cvShowImage函數提供時間完成顯示
//等待時間可以根據CPU速度調整
if( cvWaitKey(2) >= 0 )
break;
}
}
//銷毀視窗
cvDestroyWindow("video");
cvDestroyWindow("background");
cvDestroyWindow("foreground");
//釋放圖像和矩陣
cvReleaseImage(&pFrImg);
cvReleaseImage(&pBkImg);
cvReleaseMat(&pFrameMat);
cvReleaseMat(&pFrMat);
cvReleaseMat(&pBkMat);
cvReleaseCapture(&pCapture);
return 0;
}
/**
* main
*/
int main(int argc, const char **argv)
{
// *** MODIFICATION: OpenCV modifications.
// Load previous image.
IplImage* prevImage = cvLoadImage("motion1.jpg", CV_LOAD_IMAGE_COLOR);
// Create two arrays with the same number of channels than the original one.
avg1 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3);
avg2 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3);
// Create image of 32 bits.
IplImage* image32 = cvCreateImage(cvSize(prevImage->width,prevImage->height), 32,3);
// Convert image to 32 bits.
cvConvertScale(prevImage,image32,1/255,0);
// Set data from previous image into arrays.
cvSetData(avg1,image32->imageData,image32->widthStep);
cvSetData(avg2,image32->imageData,image32->widthStep);
// *** MODIFICATION end
// Our main data storage vessel..
RASPISTILL_STATE state;
MMAL_STATUS_T status = MMAL_SUCCESS;
MMAL_PORT_T *camera_preview_port = NULL;
MMAL_PORT_T *camera_video_port = NULL;
MMAL_PORT_T *camera_still_port = NULL;
MMAL_PORT_T *preview_input_port = NULL;
MMAL_PORT_T *encoder_input_port = NULL;
MMAL_PORT_T *encoder_output_port = NULL;
bcm_host_init();
// Register our application with the logging system
vcos_log_register("fast", VCOS_LOG_CATEGORY);
signal(SIGINT, signal_handler);
default_status(&state);
if (state.verbose)
{
fprintf(stderr, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING);
}
// OK, we have a nice set of parameters. Now set up our components
// We have three components. Camera, Preview and encoder.
// Camera and encoder are different in stills/video, but preview
// is the same so handed off to a separate module
if ((status = create_camera_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create camera component", __func__);
}
else if ((status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create preview component", __func__);
destroy_camera_component(&state);
}
else if ((status = create_encoder_component(&state)) != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to create encode component", __func__);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
}
else
{
PORT_USERDATA callback_data;
if (state.verbose)
fprintf(stderr, "Starting component connection stage\n");
camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT];
camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT];
camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT];
preview_input_port = state.preview_parameters.preview_component->input[0];
encoder_input_port = state.encoder_component->input[0];
encoder_output_port = state.encoder_component->output[0];
if (state.preview_parameters.wantPreview )
{
if (state.verbose)
{
fprintf(stderr, "Connecting camera preview port to preview input port\n");
fprintf(stderr, "Starting video preview\n");
}
// *** USER: remove preview
// Connect camera to preview
//status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection);
}
else
{
status = MMAL_SUCCESS;
}
if (status == MMAL_SUCCESS)
{
VCOS_STATUS_T vcos_status;
if (state.verbose)
fprintf(stderr, "Connecting camera stills port to encoder input port\n");
// Now connect the camera to the encoder
status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection);
if (status != MMAL_SUCCESS)
{
vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__);
goto error;
}
// Set up our userdata - this is passed though to the callback where we need the information.
// Null until we open our filename
callback_data.file_handle = NULL;
callback_data.pstate = &state;
vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0);
vcos_assert(vcos_status == VCOS_SUCCESS);
if (status != MMAL_SUCCESS)
{
vcos_log_error("Failed to setup encoder output");
goto error;
}
FILE *output_file = NULL;
int frame = 1;
// Enable the encoder output port
encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data;
if (state.verbose)
fprintf(stderr, "Enabling encoder output port\n");
// Enable the encoder output port and tell it its callback function
status = mmal_port_enable(encoder_output_port, encoder_buffer_callback);
// Create an empty matrix with the size of the buffer.
CvMat* buf = cvCreateMat(1,60000,CV_8UC1);
// Keep buffer that gets frames from queue.
MMAL_BUFFER_HEADER_T *buffer;
// Image to be displayed.
IplImage* image;
// Keep number of buffers and index for the loop.
int num, q;
while(1)
{
// Send all the buffers to the encoder output port
num = mmal_queue_length(state.encoder_pool->queue);
for (q=0;q<num;q++)
{
buffer = mmal_queue_get(state.encoder_pool->queue);
if (!buffer)
vcos_log_error("Unable to get a required buffer %d from pool queue", q);
if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS)
vcos_log_error("Unable to send a buffer to encoder output port (%d)", q);
} // for
if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS)
vcos_log_error("%s: Failed to start capture", __func__);
else
{
// Wait for capture to complete
// For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error
// even though it appears to be all correct, so reverting to untimed one until figure out why its erratic
vcos_semaphore_wait(&callback_data.complete_semaphore);
if (state.verbose)
fprintf(stderr, "Finished capture %d\n", frame);
} // else
// Copy buffer from camera to matrix.
buf->data.ptr = buffer->data;
// This workaround is needed for the code to work
// *** TODO: investigate why.
printf("Until here works\n");
// Decode the image and display it.
image = cvDecodeImage(buf, CV_LOAD_IMAGE_COLOR);
// Destinations
CvMat* res1 = cvCreateMat(image->height,image->width,CV_8UC3);
CvMat* res2 = cvCreateMat(image->height,image->width,CV_8UC3);
// Update running averages and then scale, calculate absolute values
// and convert the result 8-bit.
// *** USER:change the value of the weight.
cvRunningAvg(image,avg2,0.0001, NULL);
cvConvertScaleAbs(avg2, res2, 1,0);
cvRunningAvg(image,avg1,0.1, NULL);
cvConvertScaleAbs(avg1, res1, 1,0);
// Show images
cvShowImage("img",image);
cvShowImage("avg1",res1);
cvShowImage("avg2",res2);
cvWaitKey(20);
// Update previous image.
cvSaveImage("motion1.jpg", image, 0);
} // end while
vcos_semaphore_delete(&callback_data.complete_semaphore);
}
else
{
mmal_status_to_int(status);
vcos_log_error("%s: Failed to connect camera to preview", __func__);
}
error:
mmal_status_to_int(status);
if (state.verbose)
fprintf(stderr, "Closing down\n");
// Disable all our ports that are not handled by connections
check_disable_port(camera_video_port);
check_disable_port(encoder_output_port);
if (state.preview_parameters.wantPreview )
mmal_connection_destroy(state.preview_connection);
mmal_connection_destroy(state.encoder_connection);
/* Disable components */
if (state.encoder_component)
mmal_component_disable(state.encoder_component);
if (state.preview_parameters.preview_component)
mmal_component_disable(state.preview_parameters.preview_component);
if (state.camera_component)
mmal_component_disable(state.camera_component);
destroy_encoder_component(&state);
raspipreview_destroy(&state.preview_parameters);
destroy_camera_component(&state);
if (state.verbose)
fprintf(stderr, "Close down completed, all components disconnected, disabled and destroyed\n\n");
}
if (status != MMAL_SUCCESS)
raspicamcontrol_check_configuration(128);
return 0;
}
detectMotion::detectMotion(char *_videoname, int Threshold)
{
this->videoname= _videoname;
T = Threshold;
//IplImage pointers
IplImage* pFrame = NULL;
IplImage* pFrImg = NULL;
IplImage* pBkImg = NULL;
//CvMat pointers
CvMat* pFrameMat = NULL;
CvMat* pFrMat = NULL;
CvMat* pBkMat = NULL;
//CvVideoWriter pointers
CvVideoWriter* vWriter = NULL;
CvCapture* pCapture = NULL;
int nFrmNum = 0;
int Mt = 0; //Motion
double TM = 0; //Total motion
double AM = 0; //Avarage motion
if( !(pCapture = cvCaptureFromFile(videoname)))
{
fprintf(stderr, "Can not open video file %s\n", videoname);
return ;
}
//For each frame
while(pFrame = cvQueryFrame( pCapture ))
{
nFrmNum++;
//memory alloc and variable intial for first frame
if(nFrmNum == 1)
{
//8 bit unsigned int array of size width*height
pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height), IPL_DEPTH_8U,1);
//
pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);
//save to gray image
cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY);
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
//convert gray image to pFrameMat pointer
cvConvert(pFrImg, pFrameMat);
cvConvert(pFrImg, pFrMat);
cvConvert(pFrImg, pBkMat);
//double temp = cvGetCaptureProperty(pCapture,CV_CAP_PROP_FPS); //fps
//init the writer pointer
vWriter = cvCreateVideoWriter ("ccfgvideo.avi", cvGetCaptureProperty(pCapture, CV_CAP_PROP_FOURCC), cvGetCaptureProperty(pCapture, CV_CAP_PROP_FPS ),cvSize (pFrame->width,pFrame->height),1);
cvWriteFrame (vWriter, pFrame);
}
else
{
//convert to gray image
cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);
cvConvert(pFrImg, pFrameMat);
//gaussian filter
//cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);
//get background frame
cvAbsDiff(pFrameMat, pBkMat, pFrMat);
//T=60
cvThreshold(pFrMat, pFrImg, T, 255.0, CV_THRESH_BINARY);
//erode and dilate to reduce hole in objects
cvErode(pFrImg, pFrImg, 0, 1);
cvDilate(pFrImg, pFrImg, 0, 1);
//calculate Mt and reset fps base on it
Mt = (cvSum(pFrImg).val[0]/255); //(pFrame->width*pFrame->height);
//cvCreateVideoWriter( const char* filename, int fourcc, double fps, CvSize frame_size, int is_color=1 );
if(Mt>0)
{
int n=cvWriteFrame (vWriter, pFrame); //write to frame
//cout<<n;
if (Mt<100)
{
cvRunningAvg(pFrameMat, pBkMat, 0.05, 0);
}
else
{
cvRunningAvg(pFrameMat, pBkMat, 0.8, 0);
}
}
else
{
cvRunningAvg(pFrameMat, pBkMat, 0.05, 0);
nFrmNum-=1;
}
/*CvScalar Mn;
CvScalar SDev;
cvAvgSdv(pFrMat,&Mn,&SDev);
Mn.val[0];*/
/*if ( SDev.val[0]<1)
{
cvRunningAvg(pFrameMat, pBkMat, 1, 0);
}
else
{
}*/
//renew background
//cvRunningAvg(pFrameMat, pBkMat, 1, 0);
cvConvert(pBkMat, pBkImg);
//wait for key interupt
if( cvWaitKey(2) >= 0 )
{
cvReleaseVideoWriter(&vWriter);
cvReleaseImage(&pFrImg);
cvReleaseImage(&pBkImg);
cvReleaseMat(&pFrameMat);
cvReleaseMat(&pFrMat);
cvReleaseMat(&pBkMat);
cvReleaseCapture(&pCapture);
std::cout<<"Frame number after deleting zero motion frames" <<nFrmNum<<std::endl;
break;
}
//
//TM+=Mt;
}
}
//AM=TM/nFrmNum;
//Release pointers
cvReleaseVideoWriter(&vWriter);
cvReleaseImage(&pFrImg);
cvReleaseImage(&pBkImg);
cvReleaseMat(&pFrameMat);
cvReleaseMat(&pFrMat);
cvReleaseMat(&pBkMat);
//print Mt and Tm
cvReleaseCapture(&pCapture);
//cout<<"Total Motion = "<<TM<<endl;
//cout<<"Average Motion = "<<AM<<endl;
std::cout<<"Frame number after deleting zero motion frames" <<nFrmNum<<std::endl;
return;
}
//--------------------------------------------------------------
bool CameraInput::update(){
vidGrabber.update();
bool newFrame = vidGrabber.isFrameNew();
if (newFrame){
calculateCaptureFramerate();
camImage->setFromPixels( vidGrabber.getPixels(), camWidth, camHeight );
if (camFormat == VID_FORMAT_RGB){
if (warp)
grayImage = rgbImage;
else
grayWarpImage = rgbImage;
}
if (camFormat == VID_FORMAT_GREYSCALE){
if (warp)
grayWarpImage.warpIntoMe( grayImage, warper.dstPoints , warper.srcPoints);
else
grayWarpImage = grayImage;
}
//now grayWarpImage has the image
if (bgSubtraction){
//absDiffWithCutoffInverted( &bgImage, &grayWarpImage, &diffImage, bgSubtractionCutOff );
cvAbsDiff(bgImage.getCvImage(), grayWarpImage.getCvImage(), diffImage.getCvImage());
diffImage.flagImageChanged();
binaryImage = diffImage;
}else {
binaryImage = grayWarpImage;
}
if (threshold)
binaryImage.threshold(thresholdVal, false);
if (invert)
binaryImage.invert();
if ( numErosions > 0 ){
for (int i=0; i<numErosions; i++)
binaryImage.erode();
}
if ( numDilations > 0 ){
for (int i=0; i<numDilations; i++)
binaryImage.dilate();
}
if (bgSubtraction){
cvRunningAvg(grayWarpImage.getCvImage(), accImage.getCvImage(), bgAccumRate);
cvConvert( accImage.getCvImage(), bgImage.getCvImage() );
bgImage.flagImageChanged();
}
}
if (uiState == SET_PROCESSING_SETTINGS){
processingPanel.update();
}
if (uiState == SET_IMAGE_WARP){
warpingPanel.update();
}
return newFrame;
}
FrameAcquirer::FrameAcquirer(SinGen *s)
{
this->sg = s;
// create all necessary instances
cvNamedWindow (WINDOW_NAME, CV_WINDOW_AUTOSIZE);
CvCapture * camera = cvCreateCameraCapture (CV_CAP_ANY);
CvMemStorage* storage = cvCreateMemStorage(0);
assert (storage);
// you do own an iSight, don't you ?!?
if (! camera)
abort ();
if(useMotion == false){
// get an initial frame and duplicate it for later work
IplImage * current_frame = cvQueryFrame (camera);
IplImage * gray_image = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
IplImage * gray_image2 = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
assert (current_frame && gray_image);
// as long as there are images ...
while (current_frame = cvQueryFrame (camera))
{
// convert to gray and downsize
cvCvtColor (current_frame, gray_image, CV_BGR2GRAY);
cvConvert( gray_image, gray_image2);
float vals[NUM_WAVES];
pixelate(gray_image,vals);
this->sg->setAmplitudes(vals);
// just show the image
cvAddWeighted( gray_image2, 0.5, gray_image, 0.5, 0.5, gray_image);
cvShowImage (WINDOW_NAME, gray_image);
// cvShowImage (WINDOW_NAME, current_frame);
// wait a tenth of a second for keypress and window drawing
int key = cvWaitKey (30);
if (key == 'q' || key == 'Q')
break;
}
}else{
IplImage * current_frame = cvQueryFrame (camera);
IplImage * gray_image = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
IplImage * avg_img = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_32F, 1);
IplImage * gavg_img = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
IplImage * diff_img = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
IplImage * diff_img2 = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
IplImage * diff_img3 = cvCreateImage(cvSize (current_frame->width, current_frame->height), IPL_DEPTH_8U, 1);
// as long as there are images ...
while (current_frame = cvQueryFrame (camera))
{
// convert to gray and downsize
cvCvtColor (current_frame, gray_image, CV_BGR2GRAY);
cvSmooth( gray_image, gray_image);
cvRunningAvg( gray_image, avg_img, .250, NULL);
cvConvert( avg_img, gavg_img );
cvAbsDiff( gray_image, gavg_img, diff_img );
cvConvert( diff_img, diff_img2 );
float vals[NUM_WAVES];
pixelate(diff_img,vals);
this->sg->setAmplitudes(vals);
if(useMotionAndLight){
pixelate(gray_image,vals);
for(int i = 0; i < NUM_WAVES; i++){
vals[i] *= C8;
}
this->sg->setFrequencies(vals);
cvAddWeighted( diff_img2, 0.5, gray_image, 0.5, 0.5, diff_img);
cvShowImage ( WINDOW_NAME, diff_img);
}else{
cvAddWeighted( diff_img, 0.5, diff_img2, 0.5, 0.5, diff_img);
cvShowImage ( WINDOW_NAME, diff_img);
}
int key = cvWaitKey (30);
if (key == 'q' || key == 'Q')
break;
}
}
// be nice and return no error
return;
}
char operateImage(Userdata *userdata) {
if (!userdata) {
return 0;
}
IplImage *image1 = userdata->input[0];
IplImage *image2 = userdata->input[1];
IplImage *imageOut = userdata->output[0];
IplImage *imageOut2 = userdata->output[1];
static int color_mode = 4;
static int smooth_mode = 0;
static int otsu_mode = 0;
static int close_mode = 0;
static int canny_mode = 0;
static int contour_mode = 0;
static int hsv_mode = 0;
static int save_img = 0;
static int history_mode = 0;
int key = userdata->key;
switch (key) {
case 'g':
color_mode++;
color_mode %= 5;
break;
case 's':
smooth_mode = !smooth_mode;
break;
case 'o':
otsu_mode = !otsu_mode;
break;
case 'e':
close_mode = !close_mode;
break;
case 'c':
canny_mode = !canny_mode;
break;
case 'b':
contour_mode = !contour_mode;
break;
case 'h':
hsv_mode = !hsv_mode;
break;
case 'H':
history_mode = !history_mode;
break;
case 'S':
save_img = 1;
break;
default:
//cout << key << "\n";
break;
}
int value = userdata->value;
int kernelSize = userdata->kernelSize;
kernelSize += 1 - (kernelSize % 2);
int lowThreshold = userdata->lowThreshold;
int highThreshold = userdata->highThreshold;
CvScalar minScalar = cvScalar(userdata->minScalar0, userdata->minScalar1, userdata->minScalar2);
CvScalar maxScalar = cvScalar(userdata->maxScalar0, userdata->maxScalar1, userdata->maxScalar2);
static IplImage *tmp1d = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 1);
static IplImage *tmp3d = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 3);
static IplImage *tmp3d2 = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 3);
static IplImage *backgroundAcc = cvCreateImage(cvGetSize(image1), IPL_DEPTH_32F, 3);
static IplImage *background = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 3);
COND_PRINTF(" \r");
char img_full_channel = 0;
switch (color_mode) {
case 0:
COND_PRINTF("Gray");
cvCvtColor(image1, tmp1d, CV_BGR2GRAY);
break;
case 1: // Hue mode
COND_PRINTF("Hue");
cvCvtColor(image1, tmp3d, CV_BGR2HSV);
cvSplit(tmp3d, tmp1d, NULL, NULL, NULL);
break;
case 2: // Saturation mode
COND_PRINTF("Saturation");
cvCvtColor(image1, tmp3d, CV_BGR2HSV);
cvSplit(tmp3d, NULL, tmp1d, NULL, NULL);
break;
case 3: // Brightness mode
COND_PRINTF("Brightness");
cvCvtColor(image1, tmp3d, CV_BGR2HSV);
cvSplit(tmp3d, NULL, NULL, tmp1d, NULL);
break;
case 4: //
COND_PRINTF("Color");
img_full_channel = 1;
break;
}
//filterByVolume(tmp1d, tmp1d, value);
if (img_full_channel) { // Image has 3 channel
#if 0
cvRunningAvg(image1, backgroundAcc, (double)userdata->accValue / 1024, NULL);
cvConvertScale(backgroundAcc, background, 1, 0);
cvNamedWindow(CONTROL_WINDOW "41", 0);
cvResizeWindow(CONTROL_WINDOW "41", 640 / 2, 480 / 2);
cvShowImage(CONTROL_WINDOW "41", background);
cvCreateTrackbar("accValue", CONTROL_WINDOW "41", &(userdata->accValue), 1024, trackbarCallback);
#endif
filterByHSV(image1, minScalar, maxScalar, tmp3d);
if (history_mode) {
cvCopy(image1, tmp3d, NULL);
cvCopy(image1, tmp3d2, NULL);
//cvCvtColor(image1, tmp3d, CV_BGR2HSV);
//CvRect rect = cvRect(userdata->size.width * 3 / 4 - 40, userdata->size.height / 2 - 40, 80, 80);
//CvRect rect = cvRect(userdata->size.width * 1 / 4 - 40, userdata->size.height / 2 - 40, userdata->size.width * 3 / 4, 80);
CvRect rect = cvRect(userdata->square.origin.x, userdata->square.origin.y, userdata->square.size.width, userdata->square.size.height);
cvSetImageROI(tmp3d, rect);
GraficarHistograma(tmp3d, tmp3d2);
cvResetImageROI(tmp3d);
cvCopy(tmp3d2, tmp3d, NULL);
}
else {
cvCopy(image1, tmp3d, NULL);
}
}
else { // Image has 1 channel
cvSmooth(tmp1d, tmp1d, CV_GAUSSIAN, 5, 0, 0, 0);
if (otsu_mode) { // Apply Otsu's method
COND_PRINTF(", Otsu");
cvThreshold(tmp1d, tmp1d, 0, 255, CV_THRESH_OTSU);
}
if (smooth_mode) { // Apply Gaussian smoothing
COND_PRINTF(", Gauss");
cvSmooth(tmp1d, tmp1d, CV_GAUSSIAN, 5, 0, 0, 0);
}
if (close_mode) {
COND_PRINTF(", closE");
int n = kernelSize;
cvErode(tmp1d, tmp1d, NULL, n);
cvDilate(tmp1d, tmp1d, NULL, n);
}
if (canny_mode) { // Apply Canny's method
COND_PRINTF(", Canny");
cvCanny(tmp1d, tmp1d, lowThreshold, highThreshold, 3);
cvDilate(tmp1d, tmp1d, NULL, 1);
cvErode(tmp1d, tmp1d, NULL, 1);
}
cvMerge(tmp1d, tmp1d, tmp1d, NULL, tmp3d);
if (contour_mode) {
COND_PRINTF(", contours(b)");
CvMemStorage *storage = cvCreateMemStorage(0);
CvSeq *contours = NULL;
int n = cvFindContours(tmp1d, storage, &contours, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, cvPoint(0, 0));
//COND_PRINTF(", (" << n <<","<< contours->total <<")contours");
for (int i = 0; contours != NULL; contours = contours->h_next, i++) {
int cc = (int)((float)(255 * i) / contours->total);
CvScalar colorpx = CV_RGB((cc) % 256, (cc + 256 / 3) % 256, (cc + 256 * 2 / 3) % 256);
cvDrawContours(tmp3d, contours, colorpx, CV_RGB(0, 0, 0), -1, CV_FILLED, 8, cvPoint(0, 0));
}
}
}
COND_PRINTF("\r");
cvCopy(image1, image2, NULL);
cvCopy(imageOut, imageOut2, NULL);
cvCopy(tmp3d, imageOut, NULL);
//cvReleaseImage(&tmp1d);
//cvReleaseImage(&tmp3d);
//cvReleaseImage(&tmp3d2);
afterProcess(userdata);
if (save_img) {
save_img = 0;
cvSaveImage(RESOURCES "output.png", imageOut);
}
return 0;
}
int main(int argc, char **argv)
{
bool isStop = false;
const int INIT_TIME = 50;
const double BG_RATIO = 0.02; // 背景領域更新レート
const double OBJ_RATIO = 0.005; // 物体領域更新レート
const double Zeta = 10.0;
IplImage *img = NULL;
CvCapture *capture = NULL;
capture = cvCreateCameraCapture(0);
//capture = cvCaptureFromAVI("test.avi");
if(capture == NULL){
printf("capture device not found!!");
return -1;
}
img = cvQueryFrame(capture);
int w = img->width;
int h = img->height;
IplImage *imgAverage = cvCreateImage(cvSize(w, h), IPL_DEPTH_32F, 3);
IplImage *imgSgm = cvCreateImage(cvSize(w, h), IPL_DEPTH_32F, 3);
IplImage *imgTmp = cvCreateImage(cvSize(w, h), IPL_DEPTH_32F, 3);
IplImage *img_lower = cvCreateImage(cvSize(w, h), IPL_DEPTH_32F, 3);
IplImage *img_upper = cvCreateImage(cvSize(w, h), IPL_DEPTH_32F, 3);
IplImage *imgSilhouette = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 1);
IplImage *imgSilhouetteInv = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 1);
IplImage *imgResult = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 3);
printf("背景初期化中...\n");
cvSetZero(imgAverage);
for(int i = 0; i < INIT_TIME; i++){
img = cvQueryFrame(capture);
cvAcc(img, imgAverage);
printf("輝度平均 %d/%d\n", i, INIT_TIME);
}
cvConvertScale(imgAverage, imgAverage, 1.0 / INIT_TIME);
cvSetZero(imgSgm);
for(int i = 0; i < INIT_TIME; i++){
img = cvQueryFrame(capture);
cvConvert(img, imgTmp);
cvSub(imgTmp, imgAverage, imgTmp);
cvPow(imgTmp, imgTmp, 2.0);
cvConvertScale(imgTmp, imgTmp, 2.0);
cvPow(imgTmp, imgTmp, 0.5);
cvAcc(imgTmp, imgSgm);
printf("輝度振幅 %d/%d\n", i, INIT_TIME);
}
cvConvertScale(imgSgm, imgSgm, 1.0 / INIT_TIME);
printf("背景初期化完了\n");
char winNameCapture[] = "Capture";
char winNameSilhouette[] = "Silhouette";
cvNamedWindow(winNameCapture, CV_WINDOW_AUTOSIZE);
cvNamedWindow(winNameSilhouette, CV_WINDOW_AUTOSIZE);
while(1){
if(!isStop){
img = cvQueryFrame(capture);
if(img == NULL) break;
cvConvert(img, imgTmp);
// 輝度範囲
cvSub(imgAverage, imgSgm, img_lower);
cvSubS(img_lower, cvScalarAll(Zeta), img_lower);
cvAdd(imgAverage, imgSgm, img_upper);
cvAddS(img_upper, cvScalarAll(Zeta), img_upper);
cvInRange(imgTmp, img_lower, img_upper, imgSilhouette);
// 輝度振幅
cvSub(imgTmp, imgAverage, imgTmp);
cvPow(imgTmp, imgTmp, 2.0);
cvConvertScale(imgTmp, imgTmp, 2.0);
cvPow(imgTmp, imgTmp, 0.5);
// 背景領域を更新
cvRunningAvg(img, imgAverage, BG_RATIO, imgSilhouette);
cvRunningAvg(imgTmp, imgSgm, BG_RATIO, imgSilhouette);
// 物体領域を更新
cvNot(imgSilhouette, imgSilhouetteInv);
cvRunningAvg(imgTmp, imgSgm, OBJ_RATIO, imgSilhouetteInv);
cvErode(imgSilhouette, imgSilhouette, NULL, 1); // 収縮
cvDilate(imgSilhouette, imgSilhouette, NULL, 2); // 膨張
cvErode(imgSilhouette, imgSilhouette, NULL, 1); // 収縮
cvMerge(imgSilhouette, imgSilhouette, imgSilhouette, NULL, imgResult);
cvShowImage(winNameCapture, img);
cvShowImage(winNameSilhouette, imgResult);
}
int waitKey = cvWaitKey(33);
if(waitKey == 'q') break;
if(waitKey == ' '){
isStop = !isStop;
if(isStop) printf("stop\n");
else printf("start\n");
}
}
cvReleaseCapture(&capture);
cvDestroyWindow(winNameCapture);
cvDestroyWindow(winNameSilhouette);
return 0;
}
int main( int argc, char** argv )
{
IplImage *current_frame=NULL;
IplImage *running_average_background=NULL;
IplImage *static_background_image=NULL;
IplImage *static_moving_mask_image=NULL;
IplImage *running_average_background_image=NULL;
IplImage *running_average_moving_mask_image=NULL;
IplImage *running_gaussian_average_background_average=NULL;
IplImage *running_gaussian_average_background_sd=NULL;
IplImage *running_gaussian_average_sd_image=NULL;
IplImage *running_gaussian_average_background_image=NULL;
IplImage *running_gaussian_average_moving_mask_image=NULL;
IplImage *change_and_remain_changed_background_image=NULL;
IplImage *subtracted_image=NULL;
IplImage *moving_mask_image=NULL;
int user_clicked_key=0;
int show_ch = 'm';
bool paused = false;
// Load the video (AVI) file
CvCapture *capture = cvCaptureFromAVI( " " ); //Add here the inputh video path
// Ensure AVI opened properly
if( !capture )
return 1;
// Get Frames Per Second in order to playback the video at the correct speed
int fps = ( int )cvGetCaptureProperty( capture, CV_CAP_PROP_FPS );
// Explain the User Interface
printf( "Hot keys: \n"
"\tESC - quit the program\n"
"\tSPACE - pause/resume the video\n");
// Create display windows for images
cvNamedWindow( "Input video", 0 );
cvNamedWindow( "Static Background", 0 );
cvNamedWindow( "Running Average Background", 0 );
cvNamedWindow( "Running Gaussian Average Background", 0 );
cvNamedWindow( "Running Gaussian Average Stan. Dev.", 0 );
cvNamedWindow( "Moving Points - Static", 0 );
cvNamedWindow( "Moving Points - Running Average", 0 );
cvNamedWindow( "Moving Points - Running Gaussian Average", 0 );
// Setup mouse callback on the original image so that the user can see image values as they move the
// cursor over the image.
cvSetMouseCallback( "Input video", on_mouse_show_values, 0 );
window_name_for_on_mouse_show_values="Input video";
while( user_clicked_key != ESC ) {
// Get current video frame
current_frame = cvQueryFrame( capture );
if( !current_frame ) // No new frame available
break;
image_for_on_mouse_show_values = current_frame; // Assign image for mouse callback
cvShowImage( "Input video", current_frame );
if (static_background_image == NULL)
{ // The first time around the loop create the images for processing
// General purpose images
subtracted_image = cvCloneImage( current_frame );
// Static backgound images
static_background_image = cvCloneImage( current_frame );
static_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 );
cvShowImage( "Static Background", static_background_image );
// Running average images
running_average_background = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 );
//cvZero(running_average_background);
cvConvert(current_frame, running_average_background);
running_average_background_image = cvCloneImage( current_frame );
running_average_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 );
// Running Gaussian average images
running_gaussian_average_background_image = cvCloneImage( current_frame );
running_gaussian_average_sd_image = cvCloneImage( current_frame );
running_gaussian_average_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 );
running_gaussian_average_background_average = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 );
cvConvert(current_frame, running_gaussian_average_background_average);
running_gaussian_average_background_sd = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 );
cvZero(running_gaussian_average_background_sd);
}
// Static Background Processing
cvAbsDiff( current_frame, static_background_image, subtracted_image );
cvThreshold( subtracted_image, static_moving_mask_image, 30, 255, CV_THRESH_BINARY );
cvShowImage( "Moving Points - Static", static_moving_mask_image );
// Running Average Background Processing
cvRunningAvg( current_frame, running_average_background, 0.01 /*, moving_mask_image*/ );
cvConvert( running_average_background, running_average_background_image );
cvAbsDiff( current_frame, running_average_background_image, subtracted_image );
cvThreshold( subtracted_image, running_average_moving_mask_image, 30, 255, CV_THRESH_BINARY );
cvShowImage( "Running Average Background", running_average_background_image );
cvShowImage( "Moving Points - Running Average", running_average_moving_mask_image );
// Running Gaussian Average Background Processing
update_running_gaussian_averages( current_frame, running_gaussian_average_background_average, running_gaussian_average_background_sd );
cvConvertScaleAbs( running_gaussian_average_background_average, running_gaussian_average_background_image, 1.0, 0 );
cvShowImage( "Running Gaussian Average Background", running_gaussian_average_background_image );
cvConvertScaleAbs( running_gaussian_average_background_sd, running_gaussian_average_sd_image, 10.0, 0 );
cvShowImage( "Running Gaussian Average Stan. Dev.", running_gaussian_average_sd_image );
determine_moving_points_using_running_gaussian_averages( current_frame, running_gaussian_average_background_average, running_gaussian_average_background_sd, running_gaussian_average_moving_mask_image );
cvShowImage( "Moving Points - Running Gaussian Average", running_gaussian_average_moving_mask_image );
// Deal with user input, and wait for the delay between frames
do {
if( user_clicked_key == ' ' )
{
paused = !paused;
}
if (paused)
user_clicked_key = cvWaitKey(0);
else user_clicked_key = cvWaitKey( 1000 / fps );
} while (( user_clicked_key != ESC ) && ( user_clicked_key != -1 ));
}
/* free memory */
cvReleaseCapture( &capture );
cvDestroyWindow( "Input video" );
cvDestroyWindow( "Static Background" );
cvDestroyWindow( "Running Average Background" );
cvDestroyWindow( "Running Gaussian Average Background" );
cvDestroyWindow( "Running Gaussian Average Stan. Dev." );
cvDestroyWindow( "Moving Points - Static" );
cvDestroyWindow( "Moving Points - Running Average" );
cvDestroyWindow( "Moving Points - Running Gaussian Average" );
return 0;
}
