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);
}
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;
}
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;
}
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 );
}
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);
}
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;
}
int main(int argc, char** argv){
setupVideoWriting();
int width = image_width;
int height = image_height;
setupBoard(width, height, argc, argv);
setupScreen(width, height);
initShaders();
loadTexture();
setupTexture();
setupBuffers();
glutDisplayFunc(&drawScene);
glutIdleFunc(&replay);
glutMainLoop();
cvReleaseVideoWriter(&writer);
return 0;
}
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");
}
StereoDisplay::~StereoDisplay(void) // Any User DeInitialization Goes Here
{
if( true == recording_ )
cvReleaseVideoWriter(&writer_);
delete camera0_;
delete camera1_;
}
bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
{
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::KEYDOWN):
{
switch(ea.getKey())
{
case 'f':
case 'F':
flip = !flip;
break;
case 'q':
case 'Q':
if(writer) cvReleaseVideoWriter(&writer);
if(capture) cvReleaseCapture(&capture);
exit(0);
break;
case ' ':
tracker->GetDetector()->SetThreshold(15.0);
tracker->AttatchReferenceImage(gray);
tracker->TrainingReference(4.0, 8);
tracker->GetDetector()->SetThreshold(fastThreshold);
break;
}
}
break;
default:
return false;
break;
}
}
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");
}
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 = 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;
}
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;
}
void MainWindow::ReleaseVideoWriter()
{
if (writer)
{
cvReleaseVideoWriter(&writer);
writer = NULL;
}
}
CRecordProcessor::~CRecordProcessor()
{
if( outfile != NULL)
{
cvReleaseVideoWriter( &outfile );
outfile = NULL;
}
}
bool mitk::MovieGeneratorOpenCV::TerminateGenerator()
{
if (m_aviWriter)
{
cvReleaseVideoWriter(&m_aviWriter);
}
return true;
}
int main (int argc, char *argv[]) {
//~ test_bill_house();
if (argc != 7) {
fprintf(stderr, "Wrong number of arguments");
return EXIT_FAILURE;
}
// setup
char *src_path = argv[1];
char *dst_path = argv[2];
char *out_path = argv[3];
char *segments_path = argv[4];
int n_frames = atoi(argv[5]);
int fps = atoi(argv[6]);
FILE *segments_file = fopen(segments_path, "r");
int n_segments;
read_int(segments_file, &n_segments);
segment src_segments[n_segments];
segment dst_segments[n_segments];
read_segments(segments_file, src_segments, n_segments);
read_segments(segments_file, dst_segments, n_segments);
fclose(segments_file);
IplImage *src_image, *dst_image;
if ((src_image = cvLoadImage(src_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load source image\n");
exit(EXIT_FAILURE);
}
if ((dst_image = cvLoadImage(dst_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load destination image\n");
exit(EXIT_FAILURE);
}
CvVideoWriter *writer = create_video_writer(out_path, src_image->width, src_image->height, fps);
if(writer == NULL) {
fprintf(stderr, "Cannot create video writer\n");
exit(EXIT_FAILURE);
}
// morph
morph(src_image, dst_image, src_segments, dst_segments, n_segments, n_frames, writer, ASM);
cvReleaseImage(&src_image);
cvReleaseImage(&dst_image);
cvReleaseVideoWriter(&writer);
return EXIT_SUCCESS;
}
void MT_MovieExporter::releaseVideoWriter()
{
#ifndef MT_NO_OPENCV
if(m_pVideoWriter)
{
cvReleaseVideoWriter(&m_pVideoWriter);
}
#endif
}
/// <summary>
/// Destructor
/// </summary>
NuiDepthStream::~NuiDepthStream()
{
if (m_pwriter) cvReleaseVideoWriter(&m_pwriter);
if (m_pFTdepthBuffer) {
m_pFTdepthBuffer->Release();
m_pFTdepthBuffer = nullptr;
}
SafeDelete(m_pDepthInbedAPPs);
}
int lk_exit(void)
{
HANDLE hThreads[1];
DWORD dwRes;
if (CAMTHREAD)
{
hThreads[0] = CAMTHREAD;
SetEvent(CamExitEvent);
dwRes = WaitForMultipleObjects(1, hThreads, FALSE, 20);
switch(dwRes)
{
case WAIT_OBJECT_0:
case WAIT_TIMEOUT:
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"Camera closed");
//report("Camera Interface closed");
break;
default:
report_error("CamThread: unknown exit error");
break;
}
//
// reset thread exit event here
//
ResetEvent(CamExitEvent);
CloseHandle(CamExitEvent);
CloseHandle(CAMTHREAD);
CAMTHREAD=0;
}
if (capture)
{
cvReleaseImage( &image );
cvReleaseImage( &grey );
cvReleaseImage( &save_grey );
cvReleaseImage( &prev_grey );
cvReleaseImage( &pyramid );
cvReleaseImage( &prev_pyramid );
cvReleaseImage( &save_pyramid );
cvReleaseCapture( &capture );
capture=0;
cvReleaseMemStorage(&storage);
cvFree((void**)&cascade);
}
if (video_writer) cvReleaseVideoWriter(&video_writer);
cvDestroyWindow("Camera");
return(0);
}
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;
}
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;
}
/****************************************************************
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 );
}
}
void aplicar_original (const char *archivo_entrada,
bool verbose, bool frames,
const char *carpeta_frames){
static size_t bufsize = 1024;
char namebuff[bufsize + 1];
const char *filename = basename(archivo_entrada);
CvCapture *srcVid = abrir_video(archivo_entrada);
CvSize dst_size;
dst_size.width = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_WIDTH);
dst_size.height = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FRAME_HEIGHT);
double fps = cvGetCaptureProperty(srcVid,CV_CAP_PROP_FPS);
typedef struct CvVideoWriter CvVideoWriter;
snprintf(namebuff, bufsize, "%s.original.avi", archivo_entrada);
printf("\n\n%s\n\n",namebuff);
CvVideoWriter* dstVid = abrir_writer(namebuff, fps, dst_size);
if (verbose) {
cvNamedWindow("procesanding", CV_WINDOW_AUTOSIZE);
}
unsigned int framenum = 0;
while(1) {
/* Capturo un frame */
IplImage *frame = cvQueryFrame(srcVid);
framenum ++;
if(framenum==100)break;
cvWriteFrame(dstVid, frame);
if (frames) {
/* Escribo el frame */
snprintf(namebuff, bufsize, "%s/%s.original.%d.bmp",
carpeta_frames, filename, framenum);
cvSaveImage(namebuff, frame, NULL);
}
if (verbose) {
cvShowImage("procesanding", frame);
cvWaitKey(1);
}
}
if (verbose) {
cvDestroyWindow("procesanding");
}
cvReleaseVideoWriter(&dstVid);
cvReleaseCapture(&srcVid);
}
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;
}
// --------------------------------------------------------------------------
// main(Number of arguments, Value of arguments)
// Description : This is the main function.
// Return value : SUCCESS:0 ERROR:-1
// --------------------------------------------------------------------------
int main(int argc, char **argv)
{
// AR.Drone class
ARDrone ardrone;
// Initialize
if (!ardrone.open()) {
printf("Failed to initialize.\n");
return -1;
}
// Image of AR.Drone's camera
IplImage *image = ardrone.getImage();
// Filename
char filename[256];
SYSTEMTIME st;
GetLocalTime(&st);
sprintf(filename, "cam%d%02d%02d%02d%02d%02d.avi", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
// Create a video writer
CvVideoWriter *video = cvCreateVideoWriter(filename, CV_FOURCC('D','I','B',' '), 30, cvGetSize(image));
// Main loop
while (!GetAsyncKeyState(VK_ESCAPE)) {
// Update
if (!ardrone.update()) break;
// Get an image
image = ardrone.getImage();
// Write a frame
cvWriteFrame(video, image);
// Display the image
cvShowImage("camera", image);
cvWaitKey(33);
}
// Save video
cvReleaseVideoWriter(&video);
// See you
ardrone.close();
return 0;
}
void write_vid(Vid* vid, const char* fn, Seq* seq)
{
printf("Writing video to %s\n", fn);
int f = CV_FOURCC('X', 'V', 'I', 'D');
CvSize s = cvSize(vid->w, vid->h);
int c = vid->imgs[0]->nChannels > 1;
CvVideoWriter *w = cvCreateVideoWriter(fn, f, vid->fps, s, c);
int nf = seq ? seq->n : vid->nf;
for (int i = 0; i < nf; i++)
{
int idx = seq ? seq->frames[i] : i;
cvWriteFrame(w, vid->imgs[idx]);
}
cvReleaseVideoWriter(&w);
}
bool VideoIO::openSaveStream(const string &filename, const unsigned int videoWidth, const unsigned int videoHeight, const unsigned int fps)
{
bool openedVideoWriter = false;
if(!m_videoWriterInUse)
{
m_videoWriterHandle = shared_ptr<CvVideoWriter>(
cvCreateVideoWriter(filename.c_str(), -1, fps, cvSize(videoWidth, videoHeight), 1),
[](CvVideoWriter* ptr) { cvReleaseVideoWriter(&ptr); });
m_videoWriterInUse = true;
openedVideoWriter = m_videoWriterInUse;
}
else
{
clog << "A video stream is already in use. Cannot open another one till the first one is closed" << endl;
}
return openedVideoWriter;
}
static void cb_StartStopRecord( Fl_Widget*, void* )
{
if( !is_recorded )
{
if( video_image )
{
writer = cvCreateAVIWriter( "c:\\test.avi", -1, 15, cvGetSize( video_image ));
if( writer )
{
record_button->box( FL_DOWN_BOX );
is_recorded = 1;
}
}
}
else
{
record_button->box( FL_UP_BOX );
cvReleaseVideoWriter( &writer );
is_recorded = 0;
}
}
