int MicroDisplayControler::StartGrabbing(MicroDisplayInit& mdi) { int status = Fg_AcquireEx(mdi.fg, mdi.nCamPort, GRAB_INFINITE, ACQ_STANDARD, mdi.pMem0); if (status < 0){ return status; } return 0; }
int Camera::startAcquire(){ if ((Fg_AcquireEx(fg, camPort, nrOfPicturesToGrab, ACQ_STANDARD, memHandle)) < 0) { fprintf(stderr, "Fg_AcquireEx() failed: %s\n", Fg_getLastErrorDescription(fg)); Fg_FreeMemEx(fg, memHandle); Fg_FreeGrabber(fg); return FG_ERROR; } return FG_OK; }
cv::Mat E2VCameraDirectRead::GetImage() { if (HasBeenInited) { //acquire one image per subbuffer //1.fg //2.采集卡口 //3.采集帧数 //4.? //5.缓存地址 if ((Fg_AcquireEx(E2VCameraModel::fg, _camPort, 1, ACQ_STANDARD, memHandle)) < 0) { fprintf(stderr, "Fg_AcquireEx() failed: %s\n", Fg_getLastErrorDescription(fg)); errorMessageWait(); return cv::Mat(); } frameindex_t fcount = 0; frameindex_t last_pic_nr = 0; frameindex_t cur_pic_nr; cv::Mat OriginalImage; cur_pic_nr = Fg_getLastPicNumberBlockingEx(fg, last_pic_nr + 1, _camPort, 100, memHandle); if (cur_pic_nr < 0) { Fg_stopAcquire(fg, _camPort); errorMessageWait(); return cv::Mat(); } unsigned char *bytePtr = (unsigned char*)Fg_getImagePtrEx(fg, cur_pic_nr, 0, memHandle); //if (nId != -1) // ::DrawBuffer(nId, Fg_getImagePtrEx(fg, lastPicNr, 0, memHandle), (int)lastPicNr, ""); OriginalImage = cv::Mat(_frameHeight, _width, CV_8UC3, bytePtr).clone(); if (_colorType == GRAY) { cv::cvtColor(OriginalImage, OriginalImage, CV_BGR2GRAY); } fcount++; Fg_stopAcquireEx(fg, _camPort, memHandle, 0); return OriginalImage; } else return cv::Mat(); }
static void uca_pco_camera_start_readout(UcaCamera *camera, GError **error) { guint err; g_return_if_fail(UCA_IS_PCO_CAMERA(camera)); UcaPcoCameraPrivate *priv = UCA_PCO_CAMERA_GET_PRIVATE(camera); /* * TODO: Check if readout mode is possible. This is not the case for the * edge. */ err = pco_get_num_images(priv->pco, priv->active_segment, &priv->num_recorded_images); HANDLE_PCO_ERROR(err); err = Fg_AcquireEx(priv->fg, priv->fg_port, GRAB_INFINITE, ACQ_STANDARD, priv->fg_mem); FG_SET_ERROR(err, priv->fg, UCA_PCO_CAMERA_ERROR_FG_ACQUISITION); priv->last_frame = 0; priv->current_image = 1; }
static void uca_pco_camera_start_recording (UcaCamera *camera, GError **error) { g_return_if_fail(UCA_IS_PCO_CAMERA(camera)); guint err = PCO_NOERROR; UcaPcoCameraPrivate *priv = UCA_PCO_CAMERA_GET_PRIVATE(camera); guint16 binned_width, binned_height; gboolean use_extended = FALSE; gboolean transfer_async = FALSE; g_object_get (camera, "sensor-extended", &use_extended, NULL); if (use_extended) { binned_width = priv->width_ex; binned_height = priv->height_ex; } else { binned_width = priv->width; binned_height = priv->height; } binned_width /= priv->binning_h; binned_height /= priv->binning_v; if ((priv->roi_x + priv->roi_width > binned_width) || (priv->roi_y + priv->roi_height > binned_height)) { g_set_error(error, UCA_PCO_CAMERA_ERROR, UCA_PCO_CAMERA_ERROR_UNSUPPORTED, "ROI of size %ix%i @ (%i, %i) is outside of (binned) sensor size %ix%i\n", priv->roi_width, priv->roi_height, priv->roi_x, priv->roi_y, binned_width, binned_height); return; } /* * All parameters are valid. Now, set them on the camera. */ guint16 roi[4] = { priv->roi_x + 1, priv->roi_y + 1, priv->roi_x + priv->roi_width, priv->roi_y + priv->roi_height }; if (pco_set_roi(priv->pco, roi) != PCO_NOERROR) { g_set_error(error, UCA_PCO_CAMERA_ERROR, UCA_PCO_CAMERA_ERROR_LIBPCO_GENERAL, "Could not set ROI via pco_set_roi()"); return; } g_object_get(G_OBJECT(camera), "transfer-asynchronously", &transfer_async, NULL); /* * FIXME: We cannot set the binning here as this breaks communication with * the camera. Setting the binning works _before_ initializing the frame * grabber though. However, it is rather inconvenient to initialize and * de-initialize the frame grabber for each recording sequence. */ /* if (pco_set_binning(priv->pco, priv->binning_h, priv->binning_v) != PCO_NOERROR) */ /* g_warning("Cannot set binning\n"); */ if (priv->frame_width != priv->roi_width || priv->frame_height != priv->roi_height || priv->fg_mem == NULL) { guint fg_width = priv->description->type == CAMERATYPE_PCO_EDGE ? 2 * priv->roi_width : priv->roi_width; priv->frame_width = priv->roi_width; priv->frame_height = priv->roi_height; priv->num_bytes = 2; Fg_setParameter(priv->fg, FG_WIDTH, &fg_width, priv->fg_port); Fg_setParameter(priv->fg, FG_HEIGHT, &priv->frame_height, priv->fg_port); if (priv->fg_mem) Fg_FreeMemEx(priv->fg, priv->fg_mem); const guint num_buffers = 2; priv->fg_mem = Fg_AllocMemEx(priv->fg, num_buffers * priv->frame_width * priv->frame_height * sizeof(uint16_t), num_buffers); if (priv->fg_mem == NULL) { g_set_error(error, UCA_PCO_CAMERA_ERROR, UCA_PCO_CAMERA_ERROR_FG_INIT, "%s", Fg_getLastErrorDescription(priv->fg)); g_object_unref(camera); return; } } if (transfer_async) setup_fg_callback(camera); if (is_type (priv, CAMERATYPE_PCO_DIMAX_STD) || is_type (priv, CAMERATYPE_PCO4000)) pco_clear_active_segment(priv->pco); /* * Set the storage mode to FIFO buffer otherwise pco.4000 skips * frames that it is not able to send in time. */ if (is_type (priv, CAMERATYPE_PCO4000)) pco_set_storage_mode (priv->pco, STORAGE_MODE_FIFO_BUFFER); priv->last_frame = 0; err = pco_arm_camera(priv->pco); HANDLE_PCO_ERROR(err); err = pco_start_recording(priv->pco); HANDLE_PCO_ERROR(err); err = Fg_AcquireEx(priv->fg, priv->fg_port, GRAB_INFINITE, ACQ_STANDARD, priv->fg_mem); FG_SET_ERROR(err, priv->fg, UCA_PCO_CAMERA_ERROR_FG_ACQUISITION); }