int Camera::init(const char* file) {
int isSlave =0;
if ((fg = Fg_InitEx("FullAreaGray8", m_boardNr, isSlave)) == NULL) {
fprintf(stderr, "error in Fg_InitEx: %s\n", Fg_getLastErrorDescription(NULL));
exit(EXIT_FAILURE);
}
m_file = file;
if(Fg_loadConfig(fg,file)!=FG_OK){
printf("\nFile config loading failed\n");
exit(EXIT_FAILURE);
}
ComNr=m_boardNr*2;
serialInit(ComNr);
if(Fg_setParameter(fg,FG_TRIGGERMODE,&TriggerMode,camPort)==FG_OK){
printf("\nTrig config succeed\n");
}
size_t totalBufferSize = m_width * m_height * samplePerPixel * bytePerSample * nbBuffers;
memHandle = Fg_AllocMemEx(fg, totalBufferSize, nbBuffers);
if (memHandle == NULL) {
fprintf(stderr, "error in Fg_AllocMemEx: %s\n", Fg_getLastErrorDescription(fg));
Fg_FreeGrabber(fg);
exit(EXIT_FAILURE);
}
try{
// if(setExposure(m_exposure)!=FG_OK){throw 0;}
// setWidth(m_width);
// setHeight(m_height);
// setYoffset(m_yoffset);
// setXoffset(m_xoffset);
int bitAlignment = FG_LEFT_ALIGNED;
CHECK(FG_BITALIGNMENT, "FG_BITALIGNMENT", &bitAlignment);
CHECK(FG_FRAMESPERSEC, "FG_FRAMESPERSEC", &m_framespersec);
CHECK(FG_TIMEOUT, "FG_TIMEOUT", &timeout);
// startAcquire();
cout << "test" << endl;
}catch(string const& error){
cout << "ERROR: " << error <<endl;
close();
init(file);
}catch(int e){
close();
init(file);
}
return FG_OK;
}
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);
}
// 初始化采集卡与摄像机
// 设置参数初始化
// 返回Status;
int MicroDisplayInit::InitParameter(MicroDisplayInit& mdi)
{
#ifdef OUTPUT_DEBUG_INFO
if (OUTPUT_DEBUG_INFO)
{
getBoardInfo();
}
#endif
int status = 0;
char debugInfo[256];
// Initialization of the microEnable frame grabber
if (mdi.colorType == GRAY)
{
if ((mdi.fg = Fg_Init(mdi.dllNameGRAY, mdi.nBoard)) == NULL) {
return status;
}
//设置传输模式，设置后才为4k
int _FG_CAMERA_LINK_CAMTYP = FG_CL_DUALTAP_8_BIT;
if (Fg_setParameter(mdi.fg, FG_CAMERA_LINK_CAMTYP, &_FG_CAMERA_LINK_CAMTYP, mdi.nCamPort) < 0) {
return status;
}
}
else
{
if ((mdi.fg = Fg_Init(mdi.dllNameRGB, mdi.nBoard)) == NULL) {
return status;
}
//TODO:添加传输模式的调整
//int _FG_CAMERA_LINK_CAMTYP = FG_CL_DUALTAP_8_BIT;
//if (Fg_setParameter(mdi.fg, FG_CAMERA_LINK_CAMTYP, &_FG_CAMERA_LINK_CAMTYP, mdi.nCamPort) < 0) {
// return status;
//}
}
OutPutDebugInfo("Init Grabber ok");
//设置参数
int _FG_CAMERA_LINK_CAMTYP = FG_CL_DUALTAP_8_BIT;
if (Fg_setParameter(mdi.fg, FG_CAMERA_LINK_CAMTYP, &_FG_CAMERA_LINK_CAMTYP, mdi.nCamPort) < 0) {
return status;
}
if (Fg_setParameter(mdi.fg, FG_WIDTH, &mdi.width, mdi.nCamPort) < 0) {
return status;
}
if (Fg_setParameter(mdi.fg, FG_HEIGHT, &mdi.height, mdi.nCamPort) < 0) {
return status;
}
int bitAlignment = FG_LEFT_ALIGNED;
if (Fg_setParameter(mdi.fg, FG_BITALIGNMENT, &bitAlignment, mdi.nCamPort) < 0) {
return status;
}
sprintf(debugInfo, "Set Image Size on port %d (w: %d,h: %d) ok", mdi.nCamPort, mdi.width, mdi.height);
OutPutDebugInfo(debugInfo);
// Memory allocation
int format = 0;
Fg_getParameter(mdi.fg, FG_FORMAT, &format, mdi.nCamPort);
size_t bytesPerPixel = 1;
switch (format){
case FG_GRAY: bytesPerPixel = 1; break;
case FG_GRAY16: bytesPerPixel = 2; break;
case FG_COL24: bytesPerPixel = 3; break;
case FG_COL32: bytesPerPixel = 4; break;
case FG_COL30: bytesPerPixel = 5; break;
case FG_COL48: bytesPerPixel = 6; break;
}
size_t totalBufSize = mdi.width*mdi.height*mdi.nr_of_buffer*bytesPerPixel;
if ((mdi.pMem0 = Fg_AllocMemEx(mdi.fg, totalBufSize, mdi.nr_of_buffer)) == NULL){
return status;
}
else {
sprintf(debugInfo, "%d framebuffer allocated for port %d ok", mdi.nr_of_buffer, mdi.nCamPort);
OutPutDebugInfo(debugInfo);
}
return status;
}
