/** * setInput - set the name of the expected video file * * @param fileName - the name of the video file * * @return True if success. False otherwise */ bool VideoProcessor::setInput(const std::string &fileName) { fnumber = 0; tempFile = fileName; // In case a resource was already // associated with the VideoCapture instance if (isOpened()){ capture.release(); } // Open the video file if(capture.open(fileName)){ // read parameters length = capture.get(CV_CAP_PROP_FRAME_COUNT); rate = getFrameRate(); cv::Mat input; // show first frame getNextFrame(input); emit showFrame(input); emit updateBtn(); return true; } else { return false; } }
QImage *AcquisitionModule::getNextFrame() { if (m_currentImageIndex >= m_numberOfFiles) { if (m_parseDirectory) { // We have to change directory m_currentDirIndex++; openFiles(); } else { // We reached the end of the sequences! std::cout << "CDiskInput::getNextFrame() : End of the sequence reached.\n"; return NULL; } } if (m_parseDirectory && m_currentDirIndex >= m_numberOfDirs) { // We reached the end of the sequences! std::cout << "CDiskInput::getNextFrame() : End of the sequence reached.\n"; return NULL; } int retValue; QImage *tmpImage = NULL; retValue = readImageOnDisk(&tmpImage); if (retValue != 1) { // The image is corrupted, we attempt to read the following one... std::cout << "CDiskInput::getNextFrame() : ERROR : error reading an image, skipping...\n"; return getNextFrame(); } else readTimeStamp(tmpImage); m_currentImageIndex++; m_NumFrame++; return tmpImage; }
/** * writeOutput - write the processed result * */ void VideoProcessor::writeOutput() { cv::Mat input; // if no capture device has been set if (!isOpened() || !writer.isOpened()) return; // save the current position long pos = curPos; // jump to the first frame jumpTo(0); while (getNextFrame(input)) { // write output sequence if (outputFile.length()!=0) writeNextFrame(input); } // set the modify flag to false modify = false; // release the writer writer.release(); // jump back to the original position jumpTo(pos); }
/** * @brief Video::convertToEvent * @param path * @return */ EventPtr Video::convertToEvent(std::string path){ cv::Mat shot; FramePtr frame; EventPtr event; unsigned int j=0; int framecount=0; double tmpPos = getFramePos(); setFramePos(0); emit startProgress(0, (uint) getLengthFrames()); while(getNextFrame(shot)){ emit progressChanged(j); if (event.isNull()){ event = EventPtr(new Event(this)); } // create new frame frame = FramePtr(new Frame(this, shot, path)); // add frame to event event->addFrame(frame); framecount ++; j++; } setFramePos(tmpPos); return event; }
void Cube(double time){ float tm[16], rm[16], mm[16]; GLuint loc; static double prev_time = 0.0; translate(tm, 0.5, 0.5, -3.0 - time*1.5); rotate(rm, sin(time) / M_PI, cos(time) / M_PI, M_PI); matrixMultiply4x4(rm, tm, mm); if(time - prev_time > 0.03){ getNextFrame(matat); updateBigCube(matat.buffer, &bigcube); matatpos++; } glUseProgram(bigcube_shader); loc = glGetUniformLocation(bigcube_shader, "camera"); glUniformMatrix4fv(loc, 1, GL_FALSE, mm); loc = glGetUniformLocation(bigcube_shader, "pmatrix"); glUniformMatrix4fv(loc, 1, GL_FALSE, pmatrix); drawBigCube(bigcube); if(matatpos > 55){ rewindDepthVideo(matat); matatpos = 1; } }
void Matatas(double time){ static double prev_time = 0.0; GLuint loc; float tmatrix[16]; float rmatrix[16]; float mmatrix[16]; translate(tmatrix, -0.4, 3.0, -7.0); rotate(rmatrix, 0.0, 0.0, 4.1); matrixMultiply4x4(rmatrix, tmatrix, mmatrix); /* 30fps video playback */ if(time - prev_time > 0.03){ getNextFrame(matat); updateFace(matat.buffer, armface); prev_time = time; matatpos++; } glUseProgram(armface->shader); loc = glGetUniformLocation(armface->shader, "pmatrix"); glUniformMatrix4fv(loc, 1, GL_FALSE, pmatrix); loc = glGetUniformLocation(armface->shader, "mmatrix"); glUniformMatrix4fv(loc, 1, GL_FALSE, mmatrix); drawFace(armface); if(matatpos > 55){ rewindDepthVideo(matat); matatpos = 1; } }
/* The last scene. I have made it first. :-)*/ void Headbreak(double time){ static int i = 0; static float rot = 0.0; static double prev_time; GLuint loc; float tmatrix[16]; float rmatrix[16]; float mmatrix[16]; translate(tmatrix, -0.4, 3.0, -7.0); rotate(rmatrix, 0.0, 0.0, 4.1); matrixMultiply4x4(rmatrix, tmatrix, mmatrix); /* 30fps video playback */ if(time - prev_time > 0.03){ getNextFrame(head); updateFace(head.buffer, face); prev_time = time; i++; } glUseProgram(face->shader); loc = glGetUniformLocation(face->shader, "pmatrix"); glUniformMatrix4fv(loc, 1, GL_FALSE, pmatrix); loc = glGetUniformLocation(face->shader, "mmatrix"); glUniformMatrix4fv(loc, 1, GL_FALSE, mmatrix); drawFace(face); rot += 0.05; if(i > 87){ rewindDepthVideo(head); i = 1; } }
void Sprite::animate() { if ( !isAnimated() ) { return; } if ( ( timer->getCurrentTime() - previousTime ) > frameTime ) { getNextFrame(); } }
void CameraContainer::run() { if (running) return; running = true; while (running) { getNextFrame(); } }
QImage *AcquisitionModule::getFrame(int i_numFrame) { m_startFrame = i_numFrame; if (m_parseDirectory) openDir(); if (!goToFirstFrame()) return NULL; return getNextFrame(); }
void JpegReceiver::createNextPicture() { JpegWrap frame = getNextFrame(); if (frame.length == 0) return; DWORD tm = GetTickCount(); CxImage* image = new CxImage(frame.pic.get(), frame.length, CXIMAGE_FORMAT_JPG); Picture pic = Picture::createFromCxImage(image); delete image; // Capture_Log::getInstance()->log_write("Time is %d\n", GetTickCount() - tm); lockImage(); curPic = pic; releaseImage(); }
const Graphics::Surface *RlfAnimation::getFrameData(uint frameNumber) { assert(!_stream); assert(frameNumber < _frameCount); // Since this method is so expensive, first check to see if we can use // getNextFrame() it's cheap. if ((int)frameNumber == _currentFrame) { return &_currentFrameBuffer; } else if (_currentFrame + 1 == (int)frameNumber) { return getNextFrame(); } seekToFrame(frameNumber); return &_currentFrameBuffer; }
bool InputProcessing::saveDerivativeFeatures(ofstream & file, int x, int y, Size screenSize) { Mat frame = getNextFrame(frameCount++); Mat gray; cvtColor(frame, gray, CV_BGR2GRAY); vector<Point> features = getFeatures(gray); if (features.size() != 6) return false; if (DEBUG_MODE) { circle(frame, features[0], 2, Scalar(10, 255, 255), -1, 8, 0); circle(frame, features[1], 2, Scalar(20, 210, 21), -1, 8, 0); circle(frame, features[2], 2, Scalar(10, 255, 255), -1, 8, 0); circle(frame, features[3], 2, Scalar(10, 255, 255), -1, 8, 0); circle(frame, features[4], 2, Scalar(20, 210, 21), -1, 8, 0); circle(frame, features[5], 2, Scalar(10, 255, 255), -1, 8, 0); imshow(WINDOW_NAME, frame); } vector<double> derf = getDerivativeFeatures(features, gray.size()); if (derf[0] < 0 || derf[0] > 5) { return false; } if (derf[1] < 0 || derf[1] > 5) { return false; } file << derf[0] << ' ' << derf[1] << ' ' << derf[2] << ' ' << derf[3] << ' ' << derf[4] << ' ' << derf[5] << ' ' << derf[6] << ' ' << derf[7] << ' ' << derf[8] << ' ' << x / (double) screenSize.width << ' ' << y / (double) screenSize.height << endl; return true; }
bool CmpParser::load( std::string fileName, MoMa::Track *tr, bool hasRotation ){ this->openFile(fileName); unsigned int dim=hdr.sampSize/4/3; arma::cube trackCont(3,dim,hdr.nSamples); arma::Col<double> frameTemp; unsigned int t=0; while (getNextFrame(frameTemp,0)){ trackCont.slice(t)=arma::reshape(frameTemp,3,frameTemp.n_elem/3); t++; } tr->position.setData(1.0E7/hdr.sampPeriod, trackCont); tr->setFrameRate( 1.0E7/hdr.sampPeriod ); return true; }
QImage VideoDecoder::getNextFrame(qint64 time) { //if(init) { // //qDebug() << "out" << i << "\n"; if(av_read_frame(videoFormatContext, &videoPacket)>=0) { // qDebug() << "PTS" << videoPacket.pts; //qDebug() << "DTS" << videoPacket.dts; QImage res = getNextFrame(videoPacket, time); //av_free_packet(&videoPacket); return res; } else return QImage(10,10,QImage::Format_RGB888); // imggg.save("F:/kaka" + QString::number(i) + ".png"); //return imggg; } // else return QImage(800,600,QImage::Format_RGB888); }
/** \brief this function implements the acquisition thread */ static void *acquisitionThreadFunc(void* val) { std::string basename=*(static_cast<std::string*>(val)); // write basename.txt file FILE* ftxt=fopen(std::string(basename+".txt").c_str(), "w"); if (ftxt) { fprintf(ftxt, "example_image_server.cpp demo acquisition"); fclose(ftxt); } // start basename.tif file for acquired frames uint16_t* frame=(uint16_t*)malloc(img_width*img_height*sizeof(uint16_t)); TinyTIFFFile* tif=TinyTIFFWriter_open(std::string(basename+".tif").c_str(), 16, img_width, img_height); maxWriteFrames=floor(acquisition_duration/exposure); framesCompleted=0; if (tif) { HighResTimer timer; timer.start(); double seconds=timer.get_time()/1e6; double lastt=seconds; // perform acquisition bool canceled=!cam_acquisition_running; while (seconds<acquisition_duration && !canceled) { seconds = timer.get_time()/1e6; if (fabs(seconds-lastt)>=exposure) { getNextFrame(framesCompleted, frame, img_width, img_height); TinyTIFFWriter_writeImage(tif, frame); pthread_mutex_lock(&mutexframesCompleted); // count acquired frames framesCompleted++; // cancel ancquisition, when cam_acquisition_running is reset if (!cam_acquisition_running) canceled=true; pthread_mutex_unlock(&mutexframesCompleted); lastt=seconds; printf("*** acquired frame %d/%d @ %fs ***", framesCompleted, maxWriteFrames, float(seconds)); } } TinyTIFFWriter_close(tif); } free(frame); pthread_mutex_lock(&mutexframesCompleted); cam_acquisition_running=false; pthread_mutex_unlock(&mutexframesCompleted); return NULL; }
void DoBrk(UserContext *context) { void * addr = (void*)context->regs[0]; int newPageBrk = (UP_TO_PAGE(addr-VMEM_1_BASE)>>PAGESHIFT); int spPage = (DOWN_TO_PAGE((context->sp)-VMEM_1_BASE)>>PAGESHIFT) - 1; // ( - 1 to account for page in between stack and heap) TracePrintf(2, "DoBrk: Called with brk addr %p, page %d\n", addr, newPageBrk); if(newPageBrk>=spPage){ TracePrintf(1, "User Brk error: addr %p is above allocatable region - interferes with the stack\n", addr); context->regs[0]=ERROR; return; } TracePrintf(1, "DoBrk: sp page is set at %d\n", spPage); for(int i = 0; i<spPage; i++){ //map pages before new brk if(i<newPageBrk && current_process->cow.pageTable[i].valid==0){ current_process->cow.pageTable[i].valid=1; current_process->cow.pageTable[i].pfn = getNextFrame(); current_process->cow.pageTable[i].prot = (PROT_READ | PROT_WRITE); TracePrintf(2, "===============DoBrk: page %d mapped with pfn %d and read and write prots\n",\ i, current_process->cow.pageTable[i].pfn); } //unmap pages after new brk if(i>=newPageBrk && (current_process->cow.pageTable[i].valid == 1)){ TracePrintf(2, "===============DoBrk: page %d was valid with pfn %d\n", i, current_process->cow.pageTable[i].pfn); current_process->cow.pageTable[i].valid=0; if(ERROR == addFrame(current_process->cow.pageTable[i].pfn)){ TracePrintf(1, "Too Many Frames\n"); context->regs[0]=ERROR; return; } current_process->cow.pageTable[i].pfn = -1; TracePrintf(2, "===============DoBrk: page %d unmapped\n", i); } } context->regs[0]= SUCCESS; return; }
//Function executed at each frame bool AcquisitionModule::run() { if(firstTime) { firstTime = false; m_NumFrame = m_startFrame; if (m_parseDirectory) openDir(); if (!goToFirstFrame()) std::cout << "Start frame does not exist in any given directory, or file corrupted" << std::endl; } QImage *anImage = getNextFrame(); if (anImage == NULL) return false; if(m_data->currentImage != NULL) delete m_data->currentImage; m_data->currentImage = anImage; return true; }
/** * playIt - play the frames of the sequence * */ void VideoProcessor::playIt() { // current frame cv::Mat input; // if no capture device has been set if (!isOpened()) return; // is playing stop = false; // update buttons emit updateBtn(); while (!isStop()) { // read next frame if any if (!getNextFrame(input)) break; curPos = capture.get(CV_CAP_PROP_POS_FRAMES); // display input frame emit showFrame(input); // update the progress bar emit updateProgressBar(); // introduce a delay emit sleep(delay); } if (!isStop()){ emit revert(); } }
/** * motionMagnify - eulerian motion magnification * */ void VideoProcessor::motionMagnify() { // set filter setSpatialFilter(LAPLACIAN); setTemporalFilter(IIR); // create a temp file createTemp(); // current frame cv::Mat input; // output frame cv::Mat output; // motion image cv::Mat motion; std::vector<cv::Mat> pyramid; std::vector<cv::Mat> filtered; // if no capture device has been set if (!isOpened()) return; // set the modify flag to be true modify = true; // is processing stop = false; // save the current position long pos = curPos; // jump to the first frame jumpTo(0); while (!isStop()) { // read next frame if any if (!getNextFrame(input)) break; input.convertTo(input, CV_32FC3, 1.0/255.0f); // 1. convert to Lab color space cv::cvtColor(input, input, CV_BGR2Lab); // 2. spatial filtering one frame cv::Mat s = input.clone(); spatialFilter(s, pyramid); // 3. temporal filtering one frame's pyramid // and amplify the motion if (fnumber == 0){ // is first frame lowpass1 = pyramid; lowpass2 = pyramid; filtered = pyramid; } else { for (int i=0; i<levels; ++i) { curLevel = i; temporalFilter(pyramid.at(i), filtered.at(i)); } // amplify each spatial frequency bands // according to Figure 6 of paper cv::Size filterSize = filtered.at(0).size(); int w = filterSize.width; int h = filterSize.height; delta = lambda_c/8.0/(1.0+alpha); // the factor to boost alpha above the bound // (for better visualization) exaggeration_factor = 2.0; // compute the representative wavelength lambda // for the lowest spatial frequency band of Laplacian pyramid lambda = sqrt(w*w + h*h)/3; // 3 is experimental constant for (int i=levels; i>=0; i--) { curLevel = i; amplify(filtered.at(i), filtered.at(i)); // go one level down on pyramid // representative lambda will reduce by factor of 2 lambda /= 2.0; } } // 4. reconstruct motion image from filtered pyramid reconImgFromLaplacianPyramid(filtered, levels, motion); // 5. attenuate I, Q channels attenuate(motion, motion); // 6. combine source frame and motion image if (fnumber > 0) // don't amplify first frame s += motion; // 7. convert back to rgb color space and CV_8UC3 output = s.clone(); cv::cvtColor(output, output, CV_Lab2BGR); output.convertTo(output, CV_8UC3, 255.0, 1.0/255.0); // write the frame to the temp file tempWriter.write(output); // update process std::string msg= "Processing..."; emit updateProcessProgress(msg, floor((fnumber++) * 100.0 / length)); } if (!isStop()){ emit revert(); } emit closeProgressDialog(); // release the temp writer tempWriter.release(); // change the video to the processed video setInput(tempFile); // jump back to the original position jumpTo(pos); }
/** * @brief Automatically splits the video into several events provided the * given parameters. * @param threshold * @param maxcount * @param mincount * @param history * @param varThreshold * @param bShadowDetection * @param path * @return */ std::deque<EventPtr> Video::autoDetectEvents(double threshold, double maxcount, double mincount, int history, int varThreshold, bool bShadowDetection, std::string path){ cv::Mat shot; FramePtr frame; SnapshotPtr snap; EventPtr event; std::deque<EventPtr> events; unsigned int j=0; int emptycount=0; int framecount=0; int value; int absoluteThreshold = threshold/100*resolution.width*resolution.height; int i; // Initialization of background subtraction bgSubInit(history, varThreshold, bShadowDetection); setFramePos(0); emit startProgress(0, (uint) getLengthFrames()); while(getNextFrame(shot)){ QCoreApplication::processEvents(); if (toCancel){ events.clear(); canceled(); return events; } bg->NewFrame(shot); bg->Denoise(); emit progressChanged(j); value = cv::countNonZero(bg->Foreground()); // Detected change if ( value > absoluteThreshold ){ if (event.isNull()){ event = EventPtr(new Event(this)); } // create new frame frame = FramePtr(new Frame(this, shot, path)); snap = SnapshotPtr(new Snapshot(frame, bg->Foreground(), path)); // add frame to event event->addFrame(frame); event->addSnapshot(snap); framecount ++; emptycount = 0; } // Did not detect change else if (!event.isNull()){ emptycount ++; // create new frame frame = FramePtr(new Frame(this, shot, path)); snap = SnapshotPtr(new Snapshot(frame, bg->Foreground(), path)); // add frame to event event->addFrame(frame); event->addSnapshot(snap); framecount ++; if(emptycount > maxcount){ if (framecount - emptycount > mincount){ // remove extra frames with no movement for (i = 0; i < maxcount; i++){ event->remLastFrame(); event->remLastSnapshot(); } events.push_back(event); } event.clear(); emptycount = 0; framecount = 0; } } j++; } // Check if Video ended in the middle of an Event. if (!event.isNull()){ if (framecount > mincount){ events.push_back(event); } else { event.clear(); } } return events; }
QVector<Data*> Input::run(QVector<Data*>) { return getNextFrame(); }
int main (void) { // HELLO HERE I AM printf("example CAM_SERVER TCP/IP camera server ...\n\nfloat-format=%f\n\n", float(M_PI)); ///////////////////////////////////////////////////////////////////////////// // INITIALIZING the TCPIP SERVER CLASS ///////////////////////////////////////////////////////////////////////////// printf("starting TCP/IP server ...\n"); TCPIPserver* server=new TCPIPserver; server->set_port(PORT); server->open_socket(); printf("%s\n", server->get_version().c_str()); bool running=true; ///////////////////////////////////////////////////////////////////////////// // initializing basic variabls ///////////////////////////////////////////////////////////////////////////// uint16_t* frame=(uint16_t*)malloc(img_width*img_height*sizeof(uint16_t)); int img_byte_size=img_width*img_height*sizeof(uint16_t); double t=0; getNextFrame(t, frame, img_width, img_height); std::string basename="example_image_server_output"; ///////////////////////////////////////////////////////////////////////////// // initializing the acquisition thread structures + mutex ///////////////////////////////////////////////////////////////////////////// pthread_t thread1; pthread_mutex_init(&mutexframesCompleted, NULL); ///////////////////////////////////////////////////////////////////////////// // MAIN LOOP ///////////////////////////////////////////////////////////////////////////// // in this loop, instructions are read from the TCPIP connection // and the camera (in this case only a simulated device) is controlled // accordingly. The function getNextFrame() is used to retrieve frames // with a sinusoidal test pattern. ///////////////////////////////////////////////////////////////////////////// while(running) { // accept any incoming connection int connection=server->accept_connection(); printfMessage(" accepted connection %d from %s\n", connection, server->get_client_name(connection).c_str()); while(server->is_online(connection)) { // if we have an open connection, read instructions (as strings): std::string instruction=server->read_str_until(connection, '\n'); // decode instructions: if (instruction.size()>0) { if (instruction=="CONNECT") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // CONNCET TO CAMERA cam_connected=true; // SEND ANSWER TO CLIENT/QF3 server->write(connection, std::string("ACK_CONNECT\n\n")); // DONE CONNCETING TO CAMERA printfMessage("CAMERA CONNECTED!\n"); } else if (instruction=="DISCONNECT") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // DISCONNCET FROM CAMERA cam_connected=false; // SEND ANSWER TO CLIENT/QF3 server->write(connection, std::string("ACK_DISCONNECT\n\n")); // DONE DISCONNCETING FROM CAMERA printfMessage("CAMERA DISCONNECTED!\n"); } else if (instruction=="LIVE_START") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // START THE LIVE_VIEW MODE // INIT/CONFIG CAMERA for LIVE-VIEW cam_liveview=true; // SEND ANSWER TO CLIENT/QF3 server->write(connection, std::string("ACK_LIVE_START\n\n")); // DONE STARTING THE LIVE_VIEW MODE printfMessage("LIVE VIEW STARTED!\n"); } else if (instruction=="LIVE_STOP") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // STOP THE LIVE-VIEW MODE cam_liveview=false; // SEND ANSWER TO CLIENT/QF3 server->write(connection, std::string("ACK_LIVE_STOP\n\n")); printfMessage("LIVE VIEW STOPED!\n"); } else if (instruction=="SIZE_X_GET") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // RETURNS THE width OF A FRAME IN LIVE_VIEW MODE // SEND ANSWER TO CLIENT/QF3 server->write(connection, format("%d\n\n", img_width)); printfMessage("GET FRAME WIDTH!\n"); } else if (instruction=="SIZE_Y_GET") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // RETURNS THE height OF A FRAME IN LIVE_VIEW MODE // SEND ANSWER TO CLIENT/QF3 server->write(connection, format("%d\n\n", img_height)); printfMessage("GET FRAME HEIGHT!\n"); } else if (instruction=="GET_EXPOSURE") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // RETURNS THE exposure time [seconds] OF A FRAME IN LIVE_VIEW MODE // SEND ANSWER TO CLIENT/QF3 server->write(connection, format("%f\n\n", exposure)); printfMessage("GET EXPOSURE TIME!\n"); } else if (instruction=="PARAMETERS_GET") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // RETURNS A LIST OF THE AVAILABLE CAMERA PARAMETERS // SEND ANSWER TO CLIENT/QF3 // { (PARAM_FLOAT | PARAM_INT | PARAM_BOOL | PARAM_STRING);<parameter_name>;<parameter_value_as_string>;<parameter_description_as_string>;[<param_range_min>];[<param_range_max>];[(RW|RO)}\n }* \n writeParameters(server, connection); server->write(connection, "\n\n"); printfMessage("GET CAMERA PARAMETERS!\n"); } else if (instruction=="PARAMETER_GET") { // RETURNS A SINGLE PARAMETER // SEND ANSWER TO CLIENT/QF3 // { (PARAM_FLOAT | PARAM_INT | PARAM_BOOL | PARAM_STRING);<parameter_name>;<parameter_value_as_string>;<parameter_description_as_string>;[<param_range_min>];[<param_range_max>];[(RW|RO)}\n }{1} \n std::string param_name=server->read_str_until(connection, "\n\n"); writeParameters(server, connection, param_name); server->write(connection, "\n\n"); printfMessage("GET CAMERA PARAMETER '%s'!\n", param_name.c_str()); } else if (instruction=="PARAMETERS_SET") { // SET A SINGLE IMAGE PARAMETER // instruction has the form PARAMETERS_SET\n<name>;<value>\n\n std::string param_name=server->read_str_until(connection, ';'); std::string param_value=server->read_str_until(connection, "\n\n"); setParameter(param_name, param_value); printfMessage("SET CAMERA PARAMETERS ('%s' = '%s')!\n", param_name.c_str(), param_value.c_str()); } else if (instruction=="IMAGE_NEXT_GET") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // GET A NEW FRAME AND SEND IT TO THE CLIENT t++; getNextFrame(t, frame, img_width, img_height); // SEND ANSWER TO CLIENT/QF3: // 1. (IMAGE8 | IMAGE16 | IMAGE32 | IMAGE64) \n // 2. <image_width_in_pixels>\n // 3. <image_height_in_pixels>\n // 5. <image raw data of size image_width_in_pixels*image_height_in_pixels*pixel_data_size> // 6. METADATA RECORDS, DESCRIBING THE IMAGE: (from writeParameters()) // { (PARAM_FLOAT | PARAM_INT | PARAM_BOOL | PARAM_STRING);<parameter_name>;<parameter_value_as_string>[;<parameter_description_as_string>]\n }* \n server->write(connection, format("IMAGE%d\n%d\n%d\n", int(sizeof(frame[0])*8), img_width, img_height)); server->write(connection, (char*)frame, img_byte_size); writeParameters(server, connection); server->write(connection, "\n\n"); printfMessage("GET FRAME! t=%lf\n", t); } else if (instruction=="RECORD") { // START AN ACQUISITION AND SAVE DATA TO A FILE WITH THE BASENAME filename basename=server->read_str_until(connection, "\n\n"); if (!cam_acquisition_running) { printfMessage("RECORD FRAME START! basename=%s\n", basename.c_str()); // SEND ANSWER TO CLIENT/QF3 // 1. the written filenames (format FILE;<TYPE>;<FILENAME>;<DESCRIPTION>\n server->write(connection, format("FILE;TIFF;%s.tif;acquired frames\n", basename.c_str())); server->write(connection, format("FILE;TXT;%s.txt;additional text output\n", basename.c_str())); // 2. the used camera config parameters writeParameters(server, connection); server->write(connection, "\n\n"); cam_acquisition_running=true; int rc = pthread_create( &thread1, NULL, &acquisitionThreadFunc, (void*)(&basename) ); if( rc != 0 ) { cam_acquisition_running=false; printfMessage("COULD NOT START RECORD FRAME!\n"); } else { } } printfMessage("RECORD FRAME STARTED!"); } else if (instruction=="CANCEL_ACQUISITION") { // read remaining \n from "INSTRUCTION\n\n" server->read_str_until(connection, '\n'); // STOP THE LIVE-VIEW MODE pthread_mutex_lock(&mutexframesCompleted); cam_acquisition_running=false; pthread_mutex_unlock(&mutexframesCompleted); // SEND ANSWER TO CLIENT/QF3 server->write(connection, std::string("ACK_CANCEL_ACQUISITION\n\n")); printfMessage("ACQUISITION CANCELED!\n"); } else if (instruction!="\n" || instruction!="\n\n") { // PRINT ERROR MESSAGE AND IGNORE UNKNOWN INSTRUCTION printfMessage("read(%d) unknown instruction %s\n", connection, instruction.c_str()); } } } printfMessage(" connection %d closed\n", connection); } printf("stopping/freeing TCP/IP server ...\n"); free(frame); delete server; pthread_mutex_destroy(&mutexframesCompleted); pthread_exit(NULL); }
/** * colorMagnify - color magnification * */ void VideoProcessor::colorMagnify() { // set filter setSpatialFilter(GAUSSIAN); setTemporalFilter(IDEAL); // create a temp file createTemp(); // current frame cv::Mat input; // output frame cv::Mat output; // motion image cv::Mat motion; // temp image cv::Mat temp; // video frames std::vector<cv::Mat> frames; // down-sampled frames std::vector<cv::Mat> downSampledFrames; // filtered frames std::vector<cv::Mat> filteredFrames; // concatenate image of all the down-sample frames cv::Mat videoMat; // concatenate filtered image cv::Mat filtered; // if no capture device has been set if (!isOpened()) return; // set the modify flag to be true modify = true; // is processing stop = false; // save the current position long pos = curPos; // jump to the first frame jumpTo(0); // 1. spatial filtering while (getNextFrame(input) && !isStop()) { input.convertTo(temp, CV_32FC3); frames.push_back(temp.clone()); // spatial filtering std::vector<cv::Mat> pyramid; spatialFilter(temp, pyramid); downSampledFrames.push_back(pyramid.at(levels-1)); // update process std::string msg= "Spatial Filtering..."; emit updateProcessProgress(msg, floor((fnumber++) * 100.0 / length)); } if (isStop()){ emit closeProgressDialog(); fnumber = 0; return; } emit closeProgressDialog(); // 2. concat all the frames into a single large Mat // where each column is a reshaped single frame // (for processing convenience) concat(downSampledFrames, videoMat); // 3. temporal filtering temporalFilter(videoMat, filtered); // 4. amplify color motion amplify(filtered, filtered); // 5. de-concat the filtered image into filtered frames deConcat(filtered, downSampledFrames.at(0).size(), filteredFrames); // 6. amplify each frame // by adding frame image and motions // and write into video fnumber = 0; for (int i=0; i<length-1 && !isStop(); ++i) { // up-sample the motion image upsamplingFromGaussianPyramid(filteredFrames.at(i), levels, motion); resize(motion, motion, frames.at(i).size()); temp = frames.at(i) + motion; output = temp.clone(); double minVal, maxVal; minMaxLoc(output, &minVal, &maxVal); //find minimum and maximum intensities output.convertTo(output, CV_8UC3, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal)); tempWriter.write(output); std::string msg= "Amplifying..."; emit updateProcessProgress(msg, floor((fnumber++) * 100.0 / length)); } if (!isStop()) { emit revert(); } emit closeProgressDialog(); // release the temp writer tempWriter.release(); // change the video to the processed video setInput(tempFile); // jump back to the original position jumpTo(pos); }
void Composer::movitRender( Frame *dst, bool update ) { int i, j, start=0; Frame *f; //QTime time; //time.start(); Profile projectProfile = sampler->getProfile(); // find the lowest frame to process for ( j = 0 ; j < dst->sample->frames.count(); ++j ) { if ( (f = dst->sample->frames[j]->frame) ) { start = j; break; } } // build a "description" of the required chain // processing frames from bottom to top i = start; double pts = sampler->currentPTS(); QStringList currentDescriptor; int ow = projectProfile.getVideoWidth(); int oh = projectProfile.getVideoHeight(); while ( (f = getNextFrame( dst, i )) ) { FrameSample *sample = dst->sample->frames[i - 1]; // input and filters movitFrameDescriptor( "-", f, &sample->videoFilters, currentDescriptor, &projectProfile ); // transition if ( sample->transitionFrame.frame && !sample->transitionFrame.videoTransitionFilter.isNull() ) { // filters applied on first transition frame, if any currentDescriptor.append( "--" + sample->transitionFrame.videoTransitionFilter->getDescriptorFirst( pts, f, &projectProfile ) ); movitFrameDescriptor( "->", sample->transitionFrame.frame, &sample->transitionFrame.videoFilters, currentDescriptor, &projectProfile ); // filters applied on second transition frame, if any currentDescriptor.append( "-->" + sample->transitionFrame.videoTransitionFilter->getDescriptorSecond( pts, sample->transitionFrame.frame, &projectProfile ) ); currentDescriptor.append( "-<" + sample->transitionFrame.videoTransitionFilter->getDescriptor( pts, sample->transitionFrame.frame, &projectProfile ) ); } // overlay if ( (i - 1) > start ) currentDescriptor.append( GLOverlay().getDescriptor( pts, f, &projectProfile ) ); ow = f->glWidth; oh = f->glHeight; } // background currentDescriptor.append( movitBackground.getDescriptor( pts, NULL, &projectProfile ) ); // output if (outputResize.width() > 0) { currentDescriptor.append( QString("Resized output %1 %2").arg( outputResize.width() ).arg( outputResize.height() ) ); } else { currentDescriptor.append( QString("OUTPUT %1 %2").arg( ow ).arg( oh ) ); } // rebuild the chain if neccessary if ( currentDescriptor != movitChain.descriptor ) { for ( int k = 0; k < currentDescriptor.count(); k++ ) printf("%s\n", currentDescriptor[k].toLocal8Bit().data()); movitChain.descriptor = currentDescriptor; movitChain.reset(); movitChain.chain = new EffectChain( projectProfile.getVideoSAR() * projectProfile.getVideoWidth(), projectProfile.getVideoHeight(), movitPool ); i = start; Effect *last, *current = NULL; while ( (f = getNextFrame( dst, i )) ) { last = current; // input and filters MovitBranch *branch; FrameSample *sample = dst->sample->frames[i - 1]; current = movitFrameBuild( f, &sample->videoFilters, &branch ); // transition if ( sample->transitionFrame.frame && !sample->transitionFrame.videoTransitionFilter.isNull() ) { QList<Effect*> el = sample->transitionFrame.videoTransitionFilter->getMovitEffects(); // filters applied on first transition frame, if any QList<Effect*> first = sample->transitionFrame.videoTransitionFilter->getMovitEffectsFirst(); for ( int l = 0; l < first.count(); ++l ) current = movitChain.chain->add_effect( first.at( l ) ); MovitBranch *branchTrans; Effect *currentTrans = movitFrameBuild( sample->transitionFrame.frame, &sample->transitionFrame.videoFilters, &branchTrans ); // filters applied on second transition frame, if any QList<Effect*> second = sample->transitionFrame.videoTransitionFilter->getMovitEffectsSecond(); for ( int l = 0; l < second.count(); ++l ) currentTrans = movitChain.chain->add_effect( second.at( l ) ); branchTrans->filters.append( new MovitFilter( el ) ); for ( int l = 0; l < el.count(); ++l ) current = movitChain.chain->add_effect( el.at( l ), current, currentTrans ); } // overlay if ( last ) { GLOverlay *overlay = new GLOverlay(); QList<Effect*> el = overlay->getMovitEffects(); branch->overlay = new MovitFilter( el, overlay ); for ( int l = 0; l < el.count(); ++l ) current = movitChain.chain->add_effect( el.at( l ), last, current ); } } // background QList<Effect*> el = movitBackground.getMovitEffects(); movitChain.chain->add_effect( el[0] ); // output resizer if (outputResize.width() > 0) { Effect *e = new ResampleEffect(); e->set_int( "width", outputResize.width() ); e->set_int( "height", outputResize.height() ); movitChain.chain->add_effect( e ); } // output movitChain.chain->set_dither_bits( 8 ); ImageFormat output_format; output_format.color_space = COLORSPACE_sRGB; output_format.gamma_curve = GAMMA_REC_709; movitChain.chain->add_output( output_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED ); movitChain.chain->finalize(); } // update inputs data and filters parameters i = start, j = 0; int w = projectProfile.getVideoWidth(); int h = projectProfile.getVideoHeight(); while ( (f = getNextFrame( dst, i )) ) { f->glWidth = f->profile.getVideoWidth(); f->glHeight = f->profile.getVideoHeight(); f->glSAR = f->profile.getVideoSAR(); f->glOVD = 0; f->glOVDTransformList.clear(); // input and filters MovitBranch *branch = movitChain.branches[ j++ ]; branch->input->process( f, &gl ); int vf = 0; FrameSample *sample = dst->sample->frames[i - 1]; for ( int k = 0; k < branch->filters.count(); ++k ) { if ( !branch->filters[k]->filter ) sample->videoFilters[vf++]->process( branch->filters[k]->effects, pts, f, &projectProfile ); else branch->filters[k]->filter->process( branch->filters[k]->effects, pts, f, &projectProfile ); } // transition if ( sample->transitionFrame.frame && !sample->transitionFrame.videoTransitionFilter.isNull() ) { sample->transitionFrame.frame->glWidth = sample->transitionFrame.frame->profile.getVideoWidth(); sample->transitionFrame.frame->glHeight = sample->transitionFrame.frame->profile.getVideoHeight(); sample->transitionFrame.frame->glSAR = sample->transitionFrame.frame->profile.getVideoSAR(); MovitBranch *branchTrans = movitChain.branches[ j++ ]; branchTrans->input->process( sample->transitionFrame.frame, &gl ); int tvf = 0; int k; for ( k = 0; k < branchTrans->filters.count() - 1; ++k ) { if ( !branchTrans->filters[k]->filter ) sample->transitionFrame.videoFilters[tvf++]->process( branchTrans->filters[k]->effects, pts, sample->transitionFrame.frame, &projectProfile ); else branchTrans->filters[k]->filter->process( branchTrans->filters[k]->effects, pts, sample->transitionFrame.frame, &projectProfile ); } sample->transitionFrame.videoTransitionFilter->process( branchTrans->filters[k]->effects, pts, f, sample->transitionFrame.frame, &projectProfile ); } // overlay if ( branch->overlay && branch->overlay->filter ) branch->overlay->filter->process( branch->overlay->effects, pts, f, f, &projectProfile ); w = f->glWidth; h = f->glHeight; } // render waitFence(); // output resizer if (outputResize.width() > 0) { w = outputResize.width(); h = outputResize.height(); } FBO *fbo = gl.getFBO( w, h, GL_RGBA ); movitChain.chain->render_to_fbo( fbo->fbo(), w, h ); dst->glWidth = w; dst->glHeight = h; dst->glSAR = projectProfile.getVideoSAR(); if ( !update ) { dst->setVideoFrame( Frame::GLTEXTURE, w, h, dst->glSAR, projectProfile.getVideoInterlaced(), projectProfile.getVideoTopFieldFirst(), pts, projectProfile.getVideoFrameDuration() ); } dst->setFBO( fbo ); dst->setFence( gl.getFence() ); composerFence = gl.getFence(); glFlush(); //qDebug() << "elapsed" << time.elapsed(); }
bool Composer::renderVideoFrame( Frame *dst ) { int i = 0; sampler->getVideoTracks( dst ); if ( !getNextFrame( dst, i ) ) { Profile projectProfile = sampler->getProfile(); int w = projectProfile.getVideoWidth(); int h = projectProfile.getVideoHeight(); if (outputResize.width() > 0) { w = outputResize.width(); h = outputResize.height(); } if ( skipFrame > 0 ) { //qDebug() << "skipFrame" << sampler->currentPTS(); --skipFrame; dst->setVideoFrame( Frame::NONE, w, h, projectProfile.getVideoSAR(), false, false, sampler->currentPTS(), projectProfile.getVideoFrameDuration() ); return true; } // make black dst->setVideoFrame( Frame::GLTEXTURE, w, h, projectProfile.getVideoSAR(), false, false, sampler->currentPTS(), projectProfile.getVideoFrameDuration() ); waitFence(); if ( !gl.black( dst ) ) return false; dst->glWidth = dst->profile.getVideoWidth(); dst->glHeight = dst->profile.getVideoHeight(); dst->glSAR = dst->profile.getVideoSAR(); dst->setFence( gl.getFence() ); composerFence = gl.getFence(); glFlush(); return true; } if ( skipFrame > 0 ) { Frame *f; bool skip = true; for ( int i = 0 ; i < dst->sample->frames.count(); ++i) { if ( (f = dst->sample->frames[i]->frame) ) { if ( f->mmi == 0 ) { skip = false; break; } } } if ( skip ) { //qDebug() << "skipFrame" << sampler->currentPTS(); --skipFrame; Profile projectProfile = sampler->getProfile(); int w = projectProfile.getVideoWidth(); int h = projectProfile.getVideoHeight(); if (outputResize.width() > 0) { w = outputResize.width(); h = outputResize.height(); } dst->setVideoFrame( Frame::NONE, w, h, projectProfile.getVideoSAR(), false, false, sampler->currentPTS(), projectProfile.getVideoFrameDuration() ); return true; } } movitRender( dst ); return true; }
/***************************************************************************** * Timer has fired, load the next frame *****************************************************************************/ void MainWindow::timerupdate() { getNextFrame(); }
/***************************************************************************** * Load a single next frame *****************************************************************************/ void MainWindow::on_btnNextFrame_clicked() { getNextFrame(); }