VCrop::VCrop(cv::VideoCapture &capture, const float &x, const float &y, const float &size) : capture(&capture) { if (!capture.isOpened()) { std::string error_message = "Error when reading input stream"; LOG(ERROR) << error_message; throw error_message; } int frame_width = capture.get(CV_CAP_PROP_FRAME_WIDTH); int frame_height = capture.get(CV_CAP_PROP_FRAME_HEIGHT); VLOG(2) << "Frame Width: " << frame_width; VLOG(2) << "Frame Height: " << frame_height; LOG_IF(FATAL, frame_width <= 0) << "Frame width is less than zero."; LOG_IF(FATAL, frame_height <= 0) << "Frame height is less than zero."; float diameter = sqrt(frame_width * frame_width + frame_height * frame_height); cv::Point2i top_left(frame_width * x, frame_height * y); cv::Size2i rect_size(diameter * size, diameter * size); if (top_left.x + rect_size.width > frame_width || top_left.y + rect_size.height > frame_height) { LOG(ERROR) << "Size(" << rect_size << ") to too large for given x(" << top_left.x << ") and y(" << top_left.y << ") coordinate."; } roi = new cv::Rect(top_left, rect_size); VLOG(1) << "RoI: \t" << *roi; frame_rate = capture.get(CV_CAP_PROP_FPS); if (isnan(frame_rate) || frame_rate <= 0) { LOG(WARNING) << "Failed to get frame rate, setting rate to 10fps."; frame_rate = 10; } VLOG(1) << "Frame Rate: \t" << frame_rate; }
void initVideoStream(cv::VideoCapture &cap) { if (cap.isOpened()) cap.release(); cap.open(0); // open the default camera }
void mono_handler(const lcm_recv_buf_t *rbuf, const char* channel, const lcmt_stereo *msg, void *user) { // open the frame of the video specified by the message // check to see if the current video is the correct video file if (current_video_number != msg->video_number) { video_capture.release(); std::string newfile = GetMonoFilename(msg->timestamp, msg->video_number); if (newfile.empty()) { return; } std::cout << "Opening file: " << newfile << std::endl; if (!video_capture.open(newfile)) { std::cerr << "Failed to open file: " << newfile << std::endl; return; } current_video_number = msg->video_number; } video_capture.set(CV_CAP_PROP_POS_FRAMES, msg->frame_number + frame_offset); cv::Mat frame; video_capture >> frame; SendImageOverLcm(lcm_, image_channel, frame); }
void InitOpenCVModules() //OPENCV 데이터들의 초기화 { /*----------------------*/ // // // // /*-----------------------*/ if (Webcam_mode) { camera.open(Webcam_number); if (!camera.isOpened()) //소스 영상 에러체크 { //error in opening the video input cerr << "Unable to open Camera Stream" << endl; exit(EXIT_FAILURE); } camera >> Current_Frame; //카메라 소스에서 Current Frame으로 데이터를 넣어준다. } else {
cv::Mat readFrameIndex(cv::VideoCapture cap, int frameNum){ int idx = frameNum-1; cv::Mat frame; bool success; cap.set ( CV_CAP_PROP_POS_FRAMES , idx ); success = cap.retrieve(frame); return frame; }
bool SubsExtractor::open(string file) { videofile = file; bool o = cap->open(videofile); StartFrame = 0; EndFrame = cap->get(CV_CAP_PROP_FRAME_COUNT); return o; }
void shutterCB(int pos, void* param){ struct timeval t; cap.set(CV_CAP_PROP_EXPOSURE,pos); //fcount=0; // Reset frame counter, so we dont have do wait for the avg to "catch" up std::cout << "CALLBACK !!!: pos: " << pos << "Shutter read: " << cap.get(CV_CAP_PROP_EXPOSURE) << std::endl; }
bool init_opencv() { if (!capture.open(0)) { std::cerr << "error: capture.open() failed..." << std::endl; exit(-1); } capture.set(CV_CAP_PROP_FRAME_WIDTH, 640); capture.set(CV_CAP_PROP_FRAME_HEIGHT, 480); result_img.create(cv::Size(640, 480), CV_8UC3); return true; }
static int openVideo(cv::VideoCapture &capture, std::string filename){ std::cout << "abriendo video " << filename << std::endl; capture.open(filename); if (!capture.isOpened()) { std::cout << "abriendo camara " << filename << std::endl; int id_webcam = std::atoi(filename.c_str()); capture.open(id_webcam); } if (!capture.isOpened()) { // std::cout << "no puedo abrir " << filename << std::endl; return 0; } return 1; }
void* grabFunc(void* in_data) { while(running) { pthread_mutex_lock(&mutexLock); if(camera.isOpened()) { camera.grab(); } pthread_mutex_unlock(&mutexLock); } std::cout << "Grab thread exit." << std::endl; }
void cameraInit(){ /* cv::Mat frame; cap >> frame; // get a new frame from camera //cvtColor(frame, edges, CV_BGR2GRAY); //GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5); //Canny(edges, edges, 0, 30, 3); imshow("edges", frame); cv::waitKey(30); } */ cap.set(CV_CAP_PROP_FRAME_WIDTH,1280); cap.set(CV_CAP_PROP_FRAME_HEIGHT,720); cap.set(CV_CAP_PROP_FPS, 30); }
bool readParameters(int argc, char** argv) { if (argc<4) { usage(); return false; } TheInputVideo=argv[1]; /* // read input video if (TheInputVideo=="live") TheVideoCapturer.open(0); else TheVideoCapturer.open(argv[1]); if (!TheVideoCapturer.isOpened()) { cerr<<"Could not open video"<<endl; return false; }*/ //read from camera if (TheInputVideo=="live") TheVideoCapturer.open(0); else TheVideoCapturer.open(TheInputVideo); if (!TheVideoCapturer.isOpened()) { cerr<<"Could not open video"<<endl; return -1; } // read intrinsic file try { CameraParams.readFromXMLFile(argv[2]); } catch (std::exception &ex) { cout<<ex.what()<<endl; return false; } // read board file try { TheBoardConfig.readFromFile(argv[3]); } catch (std::exception &ex) { cout<<ex.what()<<endl; return false; } if(argc>4) TheMarkerSize=atof(argv[4]); else TheMarkerSize=1.; return true; }
bool read(cv::Mat &frame){ if(capture_type==0){ return videoCapture.read(frame); }else{ return imageCapture.read(frame); } };
bool isOpened(){ if(capture_type==0){ return videoCapture.isOpened(); }else{ return imageCapture.isOpened(); } };
VideoCaptureManager() : cap_(0) { if(!cap_.isOpened()){ std::cerr << "failed to open" << std::endl; } }
void fx(ForParameter for_param, cv::VideoCapture & capture_dx){ UMat *frame_dx = new UMat[farm_size]; UMat image_dx; Mat *canvas_dx = new Mat[farm_size]; double scale_dx = 1; CascadeClassifier *cascade_dx = new CascadeClassifier[farm_size]; for(int i = 0; i < farm_size; i ++) cascade_dx[i].load(cascadeName); cout << "Video dx capturing has been started ..." << endl; bool frame_success; int count = 0; while(count < 220) { for(int j = 0; j < farm_size; j ++) frame_success = capture_dx.read(frame_dx[j]); if (!frame_success) break; dx(frame_dx, canvas_dx, cascade_dx, scale_dx, count); count ++; } launch_todo_job(); }
bool Director::initCamera() { #if SIMULATOR == 1 if (!capture.isOpened()) { cerr << "Error: Can not open camera!" << endl; return false; } #else fc2Error error = fc2CreateContext(&context); if (error != FC2_ERROR_OK) { cerr << "Error in fc2CreateContext:" << error << endl; return false; } unsigned int numCameras = 0; error = fc2GetNumOfCameras(context, &numCameras); if (error != FC2_ERROR_OK) { cerr << "Error in fc2GetNumOfCameras: " << error << endl; return false; } if (numCameras == 0) { // No cameras detected cerr << "No cameras detected." << endl; return false; } // Get the 0th camera fc2PGRGuid guid; error = fc2GetCameraFromIndex(context, 0, &guid); if (error != FC2_ERROR_OK) { cerr << "Error in fc2GetCameraFromIndex: " << error << endl; return false; } error = fc2Connect(context, &guid); if (error != FC2_ERROR_OK) { cerr << "Error in fc2Connect: " << error << endl; return false; } error = fc2StartCapture(context); if (error != FC2_ERROR_OK) { cerr << "Error in fc2StartCapture: " << error << endl; return false; } error = fc2CreateImage(&rawImage); if (error != FC2_ERROR_OK) { cerr << "Error in fc2CreateImage: " << error << endl; return false; } error = fc2CreateImage(&image); if (error != FC2_ERROR_OK) { cerr << "Error in fc2CreateImage: " << error << endl; return false; } #endif return true; }
void openCamera(cv::VideoCapture& cap, int argc, const char** argv) { cv::CommandLineParser parser(argc, argv, keys); int camNum = parser.get<int>("1"); cap.open(camNum); if (!cap.isOpened()) { //help(); std::cout << "***Could not initialize capturing...***\n"; std::cout << "Current parameter's value: \n"; exit (-1); } cap.set(CV_CAP_PROP_FRAME_WIDTH, 160); cap.set(CV_CAP_PROP_FRAME_HEIGHT, 120); }
void open(string name, int type){ capture_type = type; if(capture_type==0){ videoCapture.open(name); }else{ imageCapture.open(name); } };
void takePictureBase(){ //printf("picture base\n"); cv::Mat image2(720, 1280, CV_8UC3); cap.read(image2); image2.copyTo(baseFrame); //cap.read(image2); //image2.copyTo(baseFrame); }
void OpenCVTemplateApp::update() { if(currentState == PLAY) { frameIndex = video.get(cv::CAP_PROP_POS_FRAMES); frameIndex += frameSpeed; if(frameIndex >= video.get(cv::CAP_PROP_FRAME_COUNT)-1) { frameIndex = 0; } video.set(cv::CAP_PROP_POS_FRAMES,frameIndex); video.read(frame); if(isGrayScale) { cv::cvtColor(frame, frame, cv::COLOR_BGR2GRAY); cv::goodFeaturesToTrack(frame, featurePoints, nbOfFeaturePoints, 0.01, 10, cv::Mat(), 3, 0, 0.04); } frameTexture = gl::Texture::create(fromOcv(frame)); } }
void takePictureLaser(){ //printf("picture laser\n"); cv::Mat image(720, 1280, CV_8UC3); cap.read(image); image.copyTo(laserFrame); //cap.read(image); //image.copyTo(laserFrame); }
/* * Skip n frames returning the n+1 frame. Returns NULL if no frames are * available. */ bool skipNFrames(cv::VideoCapture capture, int n, cv::Mat *image) { for(int i = 0; i < n + 1; i++) { if(!capture.read(*image)) { return false; } } return true; }
std::vector<Mat> GetFrames(cv::VideoCapture &cap) { std::vector<Mat> ansvect; for(int i=0;;i++) { //std::cout << i <<"\n"; cv::Mat frame; if (int(cap.get(CV_CAP_PROP_POS_FRAMES)) == int(cap.get(CV_CAP_PROP_FRAME_COUNT))) break; //std::cout << cap.get(CV_CAP_PROP_POS_FRAMES) <<"\t"<<cap.get(CV_CAP_PROP_FRAME_COUNT) <<"\n"; if (!cap.read(frame)) break; ansvect.push_back(frame); //cv::imshow("window", frame); //char key = cvWaitKey(0); } return ansvect; }
//----------------------------------------------------------------------------- void ShutdownCamera (const char sCameraImg[]) { /*capDriverDisconnect(hgCapWnd); lprintf("\nDelete temporary file %s\n", sCameraImg); unlink(sCameraImg);*/ cvDestroyAllWindows(); cam.release(); }
void Init(cv::VideoCapture& capture) { if(!capture.isOpened()){ std::cout << "error starting video capture" << std::endl; exit(0); } //propose a resolution capture.set(CV_CAP_PROP_FRAME_WIDTH, RESOLUTION_X); capture.set(CV_CAP_PROP_FRAME_HEIGHT, RESOLUTION_Y); //get the actual (supported) resolution ivWidth = capture.get(CV_CAP_PROP_FRAME_WIDTH); ivHeight = capture.get(CV_CAP_PROP_FRAME_HEIGHT); std::cout << "camera/video resolution: " << ivWidth << "x" << ivHeight << std::endl; cv::namedWindow("MOCTLD", 0); //CV_WINDOW_AUTOSIZE ); // cv::resizeWindow("MOCTLD", ivWidth, ivHeight); cv::setMouseCallback("MOCTLD", MouseHandler); }
void VirtualKinect::showVideoInfo(cv::VideoCapture& video) { #if (defined WIN32 || defined _WIN32 || defined WINCE) // for Windows SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_GREEN); #endif std::cout << cv::format("frame count:%.0f, size (%.0f,%.0f), fps:%.2f, fourcc:", video.get(CV_CAP_PROP_FRAME_COUNT), video.get(CV_CAP_PROP_FRAME_WIDTH), video.get(CV_CAP_PROP_FRAME_HEIGHT), video.get(CV_CAP_PROP_FPS)); int ex = static_cast<int>(video.get(CV_CAP_PROP_FOURCC)); // Get Codec Type- Int form char EXT[] = {(char)(ex & 0XFF) , (char)((ex & 0XFF00) >> 8),(char)((ex & 0XFF0000) >> 16),(char)((ex & 0XFF000000) >> 24), 0}; std::cout << EXT << std::endl << std::endl; #if (defined WIN32 || defined _WIN32 || defined WINCE) // for Windows SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); #endif }
int main() { if (!camera.isOpened()) return 1; int keyCheck = 0; resetTimer(); MouseGlove.setCenterHSV(140,161,145); MouseGlove.setLeftHSV(96,68,118); MouseGlove.setRightHSV(38,205,246); MouseGlove.setScrollHSV(63,144,204); MouseGlove.setCenterColorThreshold(45); MouseGlove.setLeftColorThreshold(0); MouseGlove.setRightColorThreshold(25); MouseGlove.setScrollColorThreshold(0); MouseGlove.setScrollAnchorYCoordinate(240); MouseGlove.setMinArea(100); leftClickStatus = false; rightClickStatus = false; while(cv::waitKey(10) != 13) { if (!camera.read(image)) return 1; cv::flip(image,image,1); MouseGlove.processCenterMarker(image); MouseGlove.processLeftMarker(image); MouseGlove.processRightMarker(image); MouseGlove.processScrollMarker(image); if (getTime() > 0.3) { coordenadasMouse = MouseGlove.getCenterMarkerCoordinates(); MouseGlove.calibrateCoordinates(coordenadasMouse); } if (MouseGlove.mouseDetected()) { MouseGlove.moveMouse(coordenadasMouse); // } //if (MouseGlove.getLeftClickStatus() != leftClickStatus) // toggleLeftClick(); //if (MouseGlove.getRightClickStatus() != rightClickStatus) // toggleRightClick(); // if (MouseGlove.scrollDetected()) { // MouseGlove.scroll(coordenadasMouse,MouseGlove.getScrollSpeed()); // } MouseGlove.displayMouseStatus(image); cv::imshow("Mouse",image); } }
int main() { if (!camera.isOpened()) return 1; int keyCheck = 0; resetTimer(); MouseGlove.setCenterHSV(104,238,203); MouseGlove.setLeftHSV(150,150,232); MouseGlove.setRightHSV(15,205,246); MouseGlove.setScrollHSV(63,144,204); MouseGlove.setCenterColorThreshold(50); MouseGlove.setLeftColorThreshold(35); MouseGlove.setRightColorThreshold(25); MouseGlove.setScrollColorThreshold(30); MouseGlove.setScrollAnchorYCoordinate(240); MouseGlove.setMinArea(100); leftClickStatus = false; rightClickStatus = false; while(cv::waitKey(10) != 13) { if (!camera.read(image)) return 1; cv::flip(image,image,1); MouseGlove.processCenterMarker(image); MouseGlove.processLeftMarker(image); MouseGlove.processRightMarker(image); MouseGlove.processScrollMarker(image); if (getTime() > 0.3) { mouseCoordinates = MouseGlove.getCenterMarkerCoordinates(); MouseGlove.calibrateCoordinates(mouseCoordinates); } if (MouseGlove.mouseDetected()) { MouseGlove.moveMouse(mouseCoordinates); } if (MouseGlove.getLeftClickStatus() != leftClickStatus) toggleLeftClick(); if (MouseGlove.getRightClickStatus() != rightClickStatus) toggleRightClick(); if (MouseGlove.scrollDetected()) { MouseGlove.scroll(mouseCoordinates,MouseGlove.getScrollSpeed()); } MouseGlove.displayMouseStatus(image); cv::imshow("Mouse Glove",image); } }
void initParams::readAndSet(cv::VideoCapture& cap, char* input){ cv::FileStorage fs(input, cv::FileStorage::READ); if(fs.isOpened()){ fs.open(input, cv::FileStorage::READ); fs["frameWidth"] >> frameWidth; fs["frameHeight"] >> frameHeight; fs["fps"] >> fps; fs["camId"] >> camId; fs["generateData"] >> genData; fs["visualizeData"] >> visualize; fs["writeVideo"] >> writeVideo; fs["generatePerfData"] >> genPerfData; fs["videoFile"] >> videoFile; fs.release(); cap.open(videoFile); if(!cap.isOpened()){ std::cerr << "Could not access video file: " << videoFile << std::endl; exit(EXIT_FAILURE); } }