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);
}
