void the_project::project_init()
{
car_of_pro = new the_car();
//camera 480*640
for_cam = cvCreateCameraCapture(1);
for_video = cvCreateFileCapture("test.avi");
image_size = cvSize(cvGetCaptureProperty(for_cam,3),cvGetCaptureProperty(for_cam,4));
wr1 = cvCreateVideoWriter("record_ori.avi",CV_FOURCC('X','V','I','D') ,15,image_size);
wr2 = cvCreateVideoWriter("record_cha.avi",CV_FOURCC('X','V','I','D') ,15,image_size);
newpoints[0]=cvPoint2D32f(0,0);
newpoints[1]=cvPoint2D32f(0,image_size.height);
newpoints[2]=cvPoint2D32f(image_size.width,image_size.height);
newpoints[3]=cvPoint2D32f(image_size.width,0);
red_min=200;
rg_max=100;
rb_max=100;
green_min=200;
gb_max=100;
gr_max=100;
}
/*
* Sets up data recording and video recording
* Will record video if exp->RECORDVID is 1
* and record data if exp->RECORDDATA is 1
*
*/
int SetupRecording(Experiment* exp) {
printf("About to setup recording\n");
char* DataFileName;
if (exp->RECORDDATA) {
if (exp->dirname == NULL || exp->outfname == NULL)
printf("exp->dirname or exp->outfname is NULL!\n");
/** Setup Writing and Write Out Comments **/
exp->DataWriter = SetUpWriteToDisk(exp->dirname,exp->outfname, exp->Worm->MemStorage);
/** We should Quit Now if any of the data Writing is not working **/
if (exp->DataWriter->error < 0 ) return -1;
/** Write the Command Line argument Out for reference **/
WriteOutCommandLineArguments(exp->DataWriter, exp->argc, exp->argv);
/** Write out the default grid size for non-protocol based illumination **/
WriteOutDefaultGridSize(exp->DataWriter, exp->Params);
/** Write the Protocol Out for reference **/
if (exp->pflag) {
WriteProtocol(exp->p, exp->DataWriter->fs);
}
BeginToWriteOutFrames(exp->DataWriter);
printf("Initialized data recording\n");
DestroyFilename(&DataFileName);
}
/** Set Up Video Recording **/
char* MovieFileName;
char* HUDSFileName;
if (exp->RECORDVID) {
if (exp->dirname == NULL || exp->outfname == NULL)
printf("exp->dirname or exp->outfname is NULL!\n");
MovieFileName = CreateFileName(exp->dirname, exp->outfname, ".avi");
HUDSFileName = CreateFileName(exp->dirname, exp->outfname, "_HUDS.avi");
exp->Vid = cvCreateVideoWriter(MovieFileName,
CV_FOURCC('M','J','P','G'), 30, cvSize(NSIZEX / 2, NSIZEY / 2),
0);
exp->VidHUDS = cvCreateVideoWriter(HUDSFileName,
CV_FOURCC('M','J','P','G'), 30, cvSize(NSIZEX / 2, NSIZEY / 2),
0);
if (exp->Vid ==NULL ) printf("\tERROR in SetupRecording! exp->Vid is NULL\n");
if (exp->VidHUDS ==NULL ) printf("\tERROR in SetupRecording! exp->VidHUDS is NULL\n");
DestroyFilename(&MovieFileName);
DestroyFilename(&HUDSFileName);
printf("Initialized video recording\n");
}
return 0;
}
OpenCVVideoWriter::OpenCVVideoWriter(const std::string &filename, const std::string &fourcc,
double fps, Size frame_size, int frame_color) throw (ICLException){
if(File(filename).exists()){
throw ICLException("file already exists");
}
if(fps <= 0){
throw ICLException("Invalid fps value");
}
if(frame_size.width < 1 || frame_size.height < 1){
throw ICLException("frame size invalid");
}
/*if(0){
throw ICLException("frame color invalid");
}*/
int FOURCC = -1;
if(fourcc.length() == 4){
FOURCC = ICL_FOURCCC(fourcc[0],fourcc[1],fourcc[2],fourcc[3]);
}
writer = cvCreateVideoWriter(filename.c_str(), FOURCC, fps,
cvSize(frame_size.width,frame_size.height)
, frame_color);
}
int main(int argc, const char * argv[]) {
CvCapture* capture = cvCreateFileCapture( argv[1] );
if (!capture) return -1;
IplImage* bgr_frame = cvQueryFrame( capture );
double fps = cvGetCaptureProperty( capture , CV_CAP_PROP_FPS );
CvSize size = cvSize(
(int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT)
);
CvVideoWriter* writer = cvCreateVideoWriter( argv[2], CV_FOURCC('M', 'J', 'P', 'G'), fps, size);
IplImage* logpolar_frame = cvCreateImage(size, IPL_DEPTH_8U, 3);
while ( (bgr_frame = cvQueryFrame(capture)) != NULL ) {
cvLogPolar(bgr_frame, logpolar_frame,
cvPoint2D32f(bgr_frame->width/2, bgr_frame->height/2),
40,
CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
cvWriteFrame(writer, logpolar_frame);
}
cvReleaseVideoWriter( &writer );
cvReleaseImage( &logpolar_frame );
cvReleaseCapture( &capture );
return 0;
}
int main(int argc, char * const argv[])
{
/* Initialize the camera */
CvCapture *CamCapture = 0;
CamCapture = cvCreateFileCapture("http://192.168.2.135:81/videostream.asf?user=viki&pwd=viki&resolution=640*480");
if (!CamCapture)
{printf("IP Cam not ready\n");
return -1;}
/* initialize video writer */
CvVideoWriter *IPCamWriter = 0;
CvSize size;
size.width = 640;
size.height = 480;
IPCamWriter = cvCreateVideoWriter("/home/viki/Videos/IPCamOut.avi", CV_FOURCC('D','I','V','X'), 4, size, 1); //needs time index in naming
/* time */
time_t current_time;
current_time = time (NULL);
long int stop_time = current_time + 10;
/* main loop */
while( current_time < stop_time )
{
/* write image to file */
cvWriteFrame(IPCamWriter, cvQueryFrame( CamCapture ));
}
/* Clean up memory */
cvReleaseCapture ( &CamCapture );
cvReleaseVideoWriter(&IPCamWriter);
}
void Tracker::replayTracker(vector<Matrixu> &vid, string statesfile, string outputvid, uint R, uint G, uint B)
{
Matrixf states;
states.DLMRead(statesfile.c_str());
Matrixu colorframe;
// save video file
CvVideoWriter* w = NULL;
if( ! outputvid.empty() ){
w = cvCreateVideoWriter( outputvid.c_str(), CV_FOURCC('I','Y','U','V'), 15, cvSize(vid[0].cols(), vid[0].rows()), 3 );
if( w==NULL ) abortError(__LINE__,__FILE__,"Error opening video file for output");
}
for( uint k=0; k<vid.size(); k++ )
{
vid[k].conv2RGB(colorframe);
colorframe.drawRect(states(k,2),states(k,3),states(k,0),states(k,1),1,0,2,R,G,B);
colorframe.drawText(("#"+int2str(k,3)).c_str(),1,25,255,255,0);
colorframe._keepIpl=true;
colorframe.display(1,2);
cvWaitKey(1);
if( w != NULL )
cvWriteFrame( w, colorframe.getIpl() );
colorframe._keepIpl=false; colorframe.freeIpl();
}
// clean up
if( w != NULL )
cvReleaseVideoWriter( &w );
}
void Image_to_video()
{
int i = 0;
IplImage* img = 0;
char image_name[13];
printf("------------- image to video ... ----------------\n");
//初始化视频编写器，参数根据实际视频文件修改
CvVideoWriter *writer = 0;
int isColor = 1;
int fps = 30; // or 25
int frameW = 400; // 744 for firewire cameras
int frameH = 240; // 480 for firewire cameras
writer=cvCreateVideoWriter("out.avi",CV_FOURCC('X','V','I','D'),fps,cvSize(frameW,frameH),isColor);
printf("\tvideo height : %d\n\tvideo width : %d\n\tfps : %d\n", frameH, frameW, fps);
//创建窗口
cvNamedWindow( "mainWin", CV_WINDOW_AUTOSIZE );
while(i<NUM_FRAME)
{
sprintf(image_name, "%s%d%s", "image", ++i, ".jpg");
img = cvLoadImage(image_name);
if(!img)
{
printf("Could not load image file...\n");
exit(0);
}
cvShowImage("mainWin", img);
char key = cvWaitKey(20);
cvWriteFrame(writer, img);
}
cvReleaseVideoWriter(&writer);
cvDestroyWindow("mainWin");
}
int main(int argc, char* argv[])
{
int frame = 11;
CvMat *orientation = cvCreateMat(3,3,CV_32FC1);
cvSetIdentity(orientation);
CvVideoWriter *writer = 0;
int isColor = 1;
int fps = 30;
int frameW = 1280;
int frameH = 720;
writer=cvCreateVideoWriter("/Users/kroo/Desktop/out.avi",-1,
fps,cvSize(frameW,frameH),isColor);
int firstFrame = 22560;
int lastFrame = 26640;
for(frame = firstFrame+1; frame<lastFrame-1; frame++) {
char firstImage [32];
char secondImage [32];
// char outImage [64];
sprintf(firstImage, "frame%d.ppm", frame);
sprintf(secondImage, "frame%d.ppm", frame+1);
// sprintf(outImage, "global_frame%d.png", frame+1);
processImagePair(firstImage, secondImage, writer, orientation);
}
cvReleaseVideoWriter(&writer);
return 0;
}
bool CaptureManager::SaveMovie(const char* avi)
{
bool resize = false;
CvSize newsize = size;
if ( Preferences::GetSavingSizeOverride() && !cvSizeEquals(Preferences::GetSavingSize(), size) ){
resize = true;
newsize = Preferences::GetSavingSize();
}
CvVideoWriter* writer = cvCreateVideoWriter(avi,
Preferences::GetSavingCodec(),
Preferences::GetSavingFpsOverride() || !fps ? Preferences::GetSavingFpsDefault() : fps,
newsize, 1);
IplImage *resized;
if (resize)
resized = cvCreateImage(newsize,8,3);
IplImage *frame_flip = cvCreateImage(newsize,8,3);
wxProgressDialog progressDlg(_T("Saving movie..."), wxString::Format(_T("Frame 0 of %d"), frameCount),frameCount, NULL, wxPD_APP_MODAL|wxPD_ELAPSED_TIME|wxPD_REMAINING_TIME|wxPD_AUTO_HIDE);
for (int i=0; i<frameCount; i++) {
progressDlg.Update(i+1, wxString::Format(_T("Frame %d of %d"), i+1, frameCount));
if (resize)
cvResize(book[i*offset]->ToIplImage(), resized);
else
resized = book[i*offset]->ToIplImage();
cvConvertImage( resized, frame_flip, CV_CVTIMG_SWAP_RB );
cvWriteFrame(writer, frame_flip);
}
cvReleaseVideoWriter(&writer);
cvReleaseImage(&frame_flip);
frame_flip = NULL;
if (resize)
cvReleaseImage(&resized);
return true;
}
int main()
{
CvCapture *capture;
IplImage *frame;
capture=cvCreateCameraCapture(0);
cvNamedWindow("Webcam",0);
CvVideoWriter *writer = NULL;
char AviFileName[]="Output.avi";
int AviForamt = 1;
int FPS = 20;
CvSize AviSize = cvSize(640,480);
int AviColor = 1;
writer=cvCreateVideoWriter(AviFileName, CV_FOURCC('P','I','M','1'), FPS,AviSize,AviColor);
if(writer == NULL)
printf("writer null..\n");
int i=0;
while(true)
{
frame = cvQueryFrame(capture);
cvWriteFrame(writer,frame);
cvShowImage("Webcam",frame);
printf("%d\n",i);
if(cvWaitKey(20)>0) break;
i++;
}
cvReleaseCapture(&capture);
cvReleaseVideoWriter(&writer);
cvDestroyWindow("Webcam");
}
void write_video_frame(raster_t *image, char *path, double fps, int action) // FIXME can only handle one video file at a time
{
static CvVideoWriter *writer=NULL;
static IplImage *frame=NULL;
return ;
if (action==0 && path) // initiate new file
{
if (writer)
{
cvReleaseVideoWriter(writer);
cvReleaseImage(frame);
}
writer = cvCreateVideoWriter(path, CV_FOURCC('X','V','I','D'), fps, cvSize(image->dim.x, image->dim.y), 1);
frame = cvCreateImage(cvSize(image->dim.x, image->dim.y), IPL_DEPTH_8U, 3);
}
if (action==2 && writer) // close and clean up
{
cvReleaseImage(frame); // FIXME crashes
frame = NULL;
cvReleaseVideoWriter(writer);
writer = NULL;
}
if (action==1 && writer)
{
convert_srgb_to_cvimage(image, frame);
cvWriteFrame(writer, frame);
}
}
//void StereoDisplay::SetFileName(LPSTR filename)
bool StereoDisplay::SetFileName(void)
{
int isColor = 1;
double fps = cvGetCaptureProperty( camera0_->capture_, CV_CAP_PROP_FPS);
CvSize size = cvSize( (int)cvGetCaptureProperty( camera0_->capture_, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty( camera0_->capture_, CV_CAP_PROP_FRAME_HEIGHT));
//http://www.xvidmovies.com/codec/
// divx.com
//writer_ = cvCreateVideoWriter( filename, CV_FOURCC_DEFAULT, fps, size, isColor ); // XP Codec Pack 2.5.1
//writer_ = cvCreateVideoWriter( filename, CV_FOURCC('X','V','I','D'), fps, size ); // XP Codec Pack 2.5.1
//writer_ = cvCreateVideoWriter( "mytest.divx", CV_FOURCC('D','I','V','X'), fps, size ); // XP Codec Pack 2.5.1
//writer_ = cvCreateVideoWriter( file_name, CV_FOURCC('U','2','6','3'), fps, size ); // XP Codec Pack 2.5.1
//writer_ = cvCreateVideoWriter( file_name, CV_FOURCC('D','I','V','3'), fps, size ); // XP Codec Pack 2.5.1
writer_ = cvCreateVideoWriter( "flv1.avi", CV_FOURCC('F','L','V','1'), fps, size ); // XP Codec Pack 2.5.1
if( NULL == writer_ )
{
return false;
}
else
{
logpolarframe_ = cvCreateImage(size, IPL_DEPTH_8U,3);
recording_ = true;
return true;
}
}
void Video_OP::Turn_Pics_into_Video(string *file_names_arr, int arr_size, int frame_rate)
{
// load first image of filename array
IplImage *img = cvLoadImage(file_names_arr[0].c_str());
// determine size of image for CvVideoWriter
CvSize size = cvSize(img->width,img->height);
string file_name_movie = file_names_arr[0];
// file-ending avi is added to filename of video
file_name_movie += ".avi";
//Creates Video Writer; parameters: (1) path where video is stored; (2) Codec for videooutput;
//(3) frame rate; (4) size of image to be stored; (5) is_color is optional; if 0 => black/white
CvVideoWriter *video_writer = cvCreateVideoWriter(file_name_movie.c_str(), CV_FOURCC('M','J','P','G'), //corresponding codec must be installed on machine
frame_rate,size);
// adds first image to videofile
int x = cvWriteFrame(video_writer,img);
// loops that loads images whose names are stored in array
// and adds images to avi file
for(int i = 1; i < arr_size; i++)
{
img = cvLoadImage(file_names_arr[i].c_str());
x = cvWriteFrame(video_writer,img);
}
cvReleaseVideoWriter(&video_writer);
cvReleaseImage(&img);
}
void CRecordProcessor::init(QSettings* settings)
{
time_t rawtime;
struct tm * timeinfo;
char buffer [80];
QObject::connect( this, SIGNAL(updateFileText(QString)), parentwnd, SLOT(getFileText(QString)));
QString txt = tr("none");
emit updateFileText( txt );
CvSize imgsize = imgdb->getImageSize();
time ( &rawtime );
timeinfo = localtime ( &rawtime );
strftime (buffer,80,"sensbli-%Y-%m-%d_%H%M%S.avi",timeinfo);
if( outfile != NULL )
{
cvReleaseVideoWriter( &outfile );
}
outfile =cvCreateVideoWriter( buffer, CV_FOURCC('I','Y','U','V'), 25, cvSize(640,480), 1);
QString filetext = buffer;
emit updateFileText( filetext );
}
int
main (int argc, char **argv)
{
CvCapture *capture = 0;
IplImage *frame = 0;
CvVideoWriter *writer;
int c, num = 0;
//CvFont font;
//char str[64];
double fps, width, height;
if ( argc == 1 || (argc >= 2 && strlen (argv[1]) == 1 && isdigit (argv[1][0])) )
{
capture = cvCreateCameraCapture (argc == 2 ? argv[1][0] - '0' : 0);
fps = 20.0;
width = 320;
height = 240;
//fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
//cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, width);
//cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, height);
}
else if ( argc >= 2 )
{
capture = cvCaptureFromFile(argv[1]);
fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH);
height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT);
}
printf ("fps=%f width=%f height=%f\n", fps, width, height);
printf ("Write to cap.avi. Finish with Esc.\n");
// FourCC http://www.fourcc.org/codecs.php
//writer = cvCreateVideoWriter( "cap.avi",
// CV_FOURCC('D','I','V','X'),
// fps, cvSize((int)width,(int)height) );
writer = cvCreateVideoWriter( "cap.avi", -1,
fps, cvSize((int)width,(int)height) );
//cvInitFont (&font, CV_FONT_HERSHEY_COMPLEX, 0.7, 0.7);
cvNamedWindow ("Capture", CV_WINDOW_AUTOSIZE);
while (1) {
frame = cvQueryFrame (capture);
if( frame == NULL ) break;
//snprintf (str, 64, "%03d[frame]", num);
//cvPutText (frame, str, cvPoint (10, 20), &font, CV_RGB (0, 255, 100));
cvWriteFrame (writer, frame);
cvShowImage ("Capture", frame);
num++;
c = cvWaitKey (10);
if (c == 'q') // exit
break;
}
cvReleaseVideoWriter (&writer);
cvReleaseCapture (&capture);
cvDestroyWindow ("Capture");
return 0;
}
int
main(int argc, char *argv[])
{
CvCapture *capture = NULL;
IplImage *src_frame, *image, *dst_frame;
char *infile, *outfile;
Matrix matrix;
Args args;
int64 t0, t1;
double tps, deltatime;
CvVideoWriter *writer;
CvSize size;
double fps;
int frame_count;
int i;
infile = argv[1];
outfile = argv[2];
args.c = argc - 3;
for (i = 0; i < 3; i++)
args.v[i] = argv[i + 3];
capture = cvCaptureFromFile(infile);
if (capture == NULL) {
printf("Could not load video \"%s\".\n", infile);
return EXIT_FAILURE;
}
src_frame = cvQueryFrame(capture);
fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
size = cvSize(
(int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH),
(int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT)
);
writer = cvCreateVideoWriter(outfile, CV_FOURCC('M', 'J', 'P', 'G'), fps, size, 1);
printf("Saving to \"%s\"...\n", outfile);
image = cvCreateImage(size, IPL_DEPTH_8U, 1);
dst_frame = cvCreateImage(size, IPL_DEPTH_8U, 3);
matrix.width = dst_frame->width;
matrix.height = dst_frame->height;
frame_count = 0;
t0 = cvGetTickCount();
while ((src_frame = cvQueryFrame(capture)) != NULL) {
cvCvtColor(src_frame, image, CV_BGR2GRAY);
matrix.data = (unsigned char *) image->imageData;
proc(&matrix, &args);
cvCvtColor(image, dst_frame, CV_GRAY2BGR);
cvWriteFrame(writer, dst_frame);
frame_count++;
}
t1 = cvGetTickCount();
tps = cvGetTickFrequency() * 1.0e6;
deltatime = (double) (t1 - t0) / tps;
printf("%d frames of %dx%d processed in %.3f seconds.\n",
frame_count, dst_frame->width, dst_frame->height,
deltatime);
cvReleaseVideoWriter(&writer);
cvReleaseImage(&dst_frame);
cvReleaseCapture(&capture);
return EXIT_SUCCESS;
}
static struct CvVideoWriter *abrir_writer(const char *archivo_salida, int fps, CvSize size) {
struct CvVideoWriter *dstVid = NULL;
dstVid = cvCreateVideoWriter(archivo_salida, CV_FOURCC('M','J','P','G'), fps, size, 1);
if(dstVid == NULL) {
fprintf(stderr, "Invalid dstVid\n");
exit(EXIT_FAILURE);
}
return dstVid;
}
int main(int arg, char** args) {
int count = psmove_count_connected();
int i;
void *frame;
if (count == 0) {
printf("No controllers connected.\n");
return 1;
}
PSMove **moves = (PSMove **)calloc(count, sizeof(PSMove *));
PSMoveTracker* tracker = psmove_tracker_new();
for (i=0; i<count; i++) {
moves[i] = psmove_connect_by_id(i);
assert(moves[i] != NULL);
while (psmove_tracker_enable(tracker, moves[i])
!= Tracker_CALIBRATED);
}
unsigned char r, g, b;
psmove_tracker_get_camera_color(tracker, moves[0], &r, &g, &b);
printf("Controller color: %02x%02x%02x\n", r, g, b);
CvVideoWriter *writer = cvCreateVideoWriter("out.avi",
CV_FOURCC('M','J','P','G'), 30, cvSize(640, 480), 1);
while ((cvWaitKey(1) & 0xFF) != 27) {
psmove_tracker_update_image(tracker);
psmove_tracker_update(tracker, NULL);
frame = psmove_tracker_get_frame(tracker);
if (frame) {
cvWriteFrame(writer, frame);
}
psmove_tracker_annotate(tracker);
frame = psmove_tracker_get_frame(tracker);
if (frame) {
cvShowImage("live camera feed", frame);
}
}
cvReleaseVideoWriter(&writer);
for (i=0; i<count; i++) {
psmove_disconnect(moves[i]);
}
psmove_tracker_free(tracker);
free(moves);
return 0;
}
CV_Video_Writer
CV__create_video_writer(
String out_file_name,
Integer four_cc,
Double fps,
CV_Size size,
Integer is_color)
{
return cvCreateVideoWriter(String__Unix(out_file_name),
four_cc, fps, *size, is_color);
}
void *record_main(void *data)
{
RecWindow *window = (RecWindow*)data;
IplImage *imagesrc = cvQueryFrame(window->capture);//Init the video read
double fps = 30;
CvSize size = cvSize((int)cvGetCaptureProperty( window->capture, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty( window->capture, CV_CAP_PROP_FRAME_HEIGHT));
CvVideoWriter *writer = cvCreateVideoWriter(TEMP_VIDEO_ADDRESS, CV_FOURCC('M','P','E','G'), fps, size );
int i = 0;
timeval time_start,time_now;
gettimeofday(&time_start,NULL);
i = gettimeofday(&time_now,NULL);
while (true)
{
i++;
imagesrc = cvQueryFrame( window->capture );
if (window->a_preview->isChecked()) //slow mode
{
if (imagesrc == NULL)
{
window->imageView = QImage((const unsigned char*)(window->NA_image->imageData), window->NA_image->width,window->NA_image->height,QImage::Format_RGB888).rgbSwapped();
window->surface->setPixmap(QPixmap::fromImage(window->imageView.scaled(window->surface_width,
floor((window->surface_width/window->NA_image->width)*window->NA_image->height),Qt::IgnoreAspectRatio,Qt::SmoothTransformation)));
return NULL;
}
window->imageView = QImage((const unsigned char*)(imagesrc->imageData), imagesrc->width,imagesrc->height,QImage::Format_RGB888).rgbSwapped();
window->surface->setPixmap(QPixmap::fromImage(window->imageView.scaled(window->surface_width,
floor((window->surface_width/imagesrc->width)*imagesrc->height),Qt::IgnoreAspectRatio,Qt::SmoothTransformation)));
}
cvWriteFrame( writer, imagesrc );
if (gettimeofday( &time_now , NULL ) < 0)
{
printf("Error in getting time");
return NULL;
}
//update info
window->info_frameNum->setText(QString("Farme = %1").arg(i));
window->info_time->setText(QString("Time : 0:%1:%2").arg((int)(time_now.tv_sec) - (int)(time_start.tv_sec)).arg((int)(time_now.tv_usec/100000)));
int elapsed = ((int)(time_now.tv_sec) - (int)(time_start.tv_sec));
if (elapsed)
window->info_fps->setText(QString("RPS = %1").arg(i/elapsed));
if (!window->isRec)
{
break;
}
}
cvReleaseVideoWriter( &writer );
return NULL;
}
void MainWindow::perpare_for_recording(IplImage* image)
{
ReleaseVideoWriter();
int fps = 10; // or 30
int frameW = image->width;
int frameH = image->height;
QString filename = get_record_filename();
writer = cvCreateVideoWriter(filename.toAscii().constData(),CV_FOURCC('X', 'V', 'I', 'D'),fps,cvSize(frameW,frameH),1);
}
static int setupVideoWriting(){
int isColor = 1;
int fps = 30;
int width = image_width;
int height = image_height;
// You can change CV_FOURCC('' to CV_FOURCC('X', '2', '6', '4') for x264 output
// Make sure you compiled ffmpeg with x264 support and OpenCV with x264
writer = cvCreateVideoWriter("out.avi", CV_FOURCC('j', 'p', 'e', 'g'), fps, cvSize(width, height), isColor);
return 0;
}
CvVideoWriter *create_video_writer (const char *output_file, int width, int height, int fps) {
CvVideoWriter *writer = NULL;
int is_color = 1;
writer = cvCreateVideoWriter(output_file,
//CV_FOURCC('M','J','P','G'),
CV_FOURCC('P','I','M','1'), // MPEG-1 codec
fps,
cvSize(width, height),
is_color);
return writer;
}
VideoSaver<scLiveStream>::VideoSaver(
const IplImage * const*pInputImage,
const char *pFilename,
double pFPS,
int pCodec):
mInputImage(pInputImage),
mVideoWriter(cvCreateVideoWriter(pFilename, pCodec, pFPS, cvGetSize(*pInputImage))),
mStartTime(Time::MillisTimestamp()),
mFrameCount(0),
mMillisecondPerFrame(1000.0/pFPS)
{
}
//Open writer to write
void videoWriter::openWriter() {
if (this->writerOpen) return;
this->writer = cvCreateVideoWriter(
this->fileName,
-1,
this->fps,
cvSize(this->getWidth(),this->getHeight()),
1
);
this->writerOpen = true;
}
/****************************************************************
Tracker::ReplaysTracker
Replays the tracker based on the saved output.
Exceptions:
None
****************************************************************/
void Tracker::ReplayTrackers(vector<Matrixu> &vid, vector<string> statesfile, string outputvid, Matrixu colors)
{
Matrixu states;
vector<Matrixu> resvid(vid.size());
Matrixu colorframe;
// save videoList file
CvVideoWriter* w = NULL;
if ( ! outputvid.empty() )
{
w = cvCreateVideoWriter( outputvid.c_str(), CV_FOURCC('x','v','i','d'), 15, cvSize(vid[0].cols(), vid[0].rows()), 3 );
if ( w==NULL )
{
abortError(__LINE__,__FILE__,"Error opening videoList file for output");
}
}
for ( uint k=0; k<vid.size(); k++ )
{
vid[k].conv2RGB(resvid[k]);
resvid[k].drawText(("#"+int2str(k,3)).c_str(),1,25,255,255,0);
}
for ( uint j=0; j < statesfile.size(); j++ )
{
states.DLMRead(statesfile[j].c_str());
for( uint k=0; k<vid.size(); k++ )
{
resvid[k].drawRect(states(k,3),states(k,2),states(k,0),states(k,1),1,0,3,colors(j,0),colors(j,1),colors(j,2));
}
}
for ( uint k=0; k<vid.size(); k++ )
{
resvid[k]._keepIpl=true;
resvid[k].display(0,2);
cvWaitKey(1);
if( w!=NULL && k<vid.size()-1)
{
Matrixu::WriteFrame(w, resvid[k]);
}
resvid[k]._keepIpl=false; resvid[k].freeIpl();
}
// clean up
if( w != NULL )
{
cvReleaseVideoWriter( &w );
}
}
FkMainWorker::FkMainWorker(int keyboardType){
dstImage = cvCreateImage(cvSize(CAM_WIDTH, CAM_HEIGHT), IPL_DEPTH_8U, 3);
preProcessor.cameraCalibrator.readFile();
motionLogger = new FkMotionLogger(postProcessor.fingerTipDetector.userHand);
vout = cvCreateVideoWriter( "C:\\Users\\Jinhyuk\\Desktop\\Working Directory\\git_WorkSpace\\src\\VideoAnalyzer\\Test.avi", CV_FOURCC('D', 'I', 'V', '3'), 30, cvSize(CAM_WIDTH, CAM_HEIGHT), 1);
#ifdef _WINDOWS
message = new FkWindowsMessage();
#endif
#ifndef _WINDOWS
message = new FkConsoleMessage();
#endif
this->mouseListener.setMessenger(message);
}
main( int argc, char* argv[] ) {
CvCapture *capture = NULL;
capture = cvCreateCameraCapture( -1 );
IplImage *frames = cvQueryFrame(capture);
// get a frame size to be used by writer structure
CvSize size = cvSize (
(int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT)
);
// declare writer structure
// use FOURCC ( Four Character Code ) MJPG, the motion jpeg codec
// output file is specified by first argument
CvVideoWriter *writer = cvCreateVideoWriter(
argv[1],
CV_FOURCC('M','J','P','G'),
30, // set fps
size
);
//Create a new window
//cvNamedWindow( "Recording ...press ESC to stop !", CV_WINDOW_AUTOSIZE );
// show capture in the window and record to a file
// record until user hits ESC key
while(1) {
frames = cvQueryFrame( capture );
if( !frames ) break;
//cvShowImage( "Recording ...press ESC to stop !", frames );
cvWriteFrame( writer, frames );
char c = cvWaitKey(33);
if( c == 27 ) break;
}
cvReleaseVideoWriter( &writer );
cvReleaseCapture ( &capture );
cvDestroyWindow ( "Recording ...press ESC to stop !");
return 0;
}
/** mvVideoWriter methods */
mvVideoWriter:: mvVideoWriter (const char* filename, unsigned framerate) :
bin_writeFrame ("mvVideoWriter - writeFrame")
{
unsigned width, height;
read_common_mv_setting ("IMG_WIDTH_COMMON", width);
read_common_mv_setting ("IMG_HEIGHT_COMMON", height);
_writer = cvCreateVideoWriter (
filename, // video file name
CV_FOURCC('P','I','M','1'), // codec
framerate, // framerate
cvSize(width,height), // size
1
);
}
/** Initialize
*
* PRECONDITION
* REQUIRE(isColor = 0 / 1)
*
* WARNING
* EXAMPLES
*
* @param filename the name of the output video file
* @param fps frame per second
* @param height image height
* @param width image width
* @param isColor whether the image is color
*
* @return void
*/
void CLHVideoWriter::Init(const char* filename, int codeType, float fps, int height, int width, int isColor)
{
mHeight = height;
mWidth = width;
if (isColor != 0)
{
mpFrameImage = cvCreateImageHeader(cvSize(width, height), IPL_DEPTH_8U, 3);
}
else
{
mpFrameImage = cvCreateImageHeader(cvSize(width, height), IPL_DEPTH_8U, 1);
}
//mpVideoWriter = cvCreateVideoWriter(filename, CV_FOURCC('D','I','V','X'), fps, cvSize(width, height), isColor);
//mpVideoWriter = cvCreateVideoWriter(filename, CV_FOURCC('X','V','I','D'), fps, cvSize(width, height), isColor);
mpVideoWriter = cvCreateVideoWriter(filename, codeType, fps, cvSize(width, height), isColor);
}
