// open camera, allocate memory
// return value: true == success, false == fail
bool CameraSetup()
{
tPvErr errCode;
unsigned long FrameSize = 0;
//open camera
if ((errCode = PvCameraOpen(GCamera.UID,ePvAccessMaster,&(GCamera.Handle))) != ePvErrSuccess)
{
if (errCode == ePvErrAccessDenied)
printf("PvCameraOpen returned ePvErrAccessDenied:\nCamera already open as Master, or camera wasn't properly closed and still waiting to HeartbeatTimeout.");
else
printf("PvCameraOpen err: %u\n", errCode);
return false;
}
// Calculate frame buffer size
if((errCode = PvAttrUint32Get(GCamera.Handle,"TotalBytesPerFrame",&FrameSize)) != ePvErrSuccess)
{
printf("CameraSetup: Get TotalBytesPerFrame err: %u\n", errCode);
return false;
}
// allocate image buffer
GCamera.Frame.ImageBuffer = new char[FrameSize];
if(!GCamera.Frame.ImageBuffer)
{
printf("CameraSetup: Failed to allocate buffers.\n");
return false;
}
GCamera.Frame.ImageBufferSize = FrameSize;
return true;
}
// open the camera
void cameraSetup(tCamera* camera) {
tPvErr err = PvCameraOpen(camera->UID, ePvAccessMaster, &(camera->Handle));
if (err != ePvErrSuccess){
stringstream buf;
buf << "failed to setup the camera : " << cameraGetError(err) << endl;
throw buf.str();
}
}
// open the camera
bool CameraOpen()
{
if(!PvCameraOpen(GCamera.Info.UniqueId,ePvAccessMonitor,&(GCamera.Handle)))
{
printf("Camera open : %s\n",GCamera.Info.SerialString);
return true;
}
else
return false;
}
bool OmniCamera::connect(void) {
if(isConnected())
return true;
tPvCameraInfoEx info[1];
unsigned long frameSize = 0;
//PvLinkCallbackRegister(CameraEventCB,ePvLinkAdd,NULL);
//PvLinkCallbackRegister(CameraEventCB,ePvLinkRemove,NULL);
if(!PvInitialize()) {
while(!PvCameraCount())
Sleep(250);
unsigned long numCameras = PvCameraListEx(info, 1, NULL, sizeof(tPvCameraInfoEx));;
if ((numCameras == 1) && (info[0].PermittedAccess & ePvAccessMaster)) {
_camera.UID = info[0].UniqueId;
if(!PvCameraOpen(_camera.UID, ePvAccessMaster, &(_camera.handle))) {
if(!PvAttrUint32Get(_camera.handle,"TotalBytesPerFrame",&frameSize)) {
_camera.frame.ImageBuffer = new char[frameSize];
unsigned long format=0;
PvAttrEnumSet(_camera.handle,"PixelFormat","Bayer8");
char text[100];
PvAttrEnumGet(_camera.handle,"PixelFormat",text,sizeof(text),&format);
printf("format %d %s\n",format,text);
if(_camera.frame.ImageBuffer) {
_camera.frame.ImageBufferSize = frameSize;
PvAttrUint32Get(_camera.handle,"Width",&_width);
PvAttrUint32Get(_camera.handle,"Height",&_height);
PvCaptureStart(_camera.handle);
PvAttrEnumSet(_camera.handle, "AcquisitionMode", "Continuous");
PvCommandRun(_camera.handle, "AcquisitionStart");
_connected = true;
return true;
}
}
}
}
}
_connected = false;
return false;
}
/*
* Method: OpenCamera()
* Purpose: open a given camera
* Comments: none
*/
tPvHandle CMainWindow::OpenCamera(unsigned long aUID,bool& aMaster)
{
tPvHandle lHandle = NULL;
if(PvCameraOpen(aUID,ePvAccessMaster,&lHandle))
{
if(!PvCameraOpen(aUID,ePvAccessMonitor,&lHandle))
aMaster = false;
}
else
{
tPvUint32 lMaxSize = 8228;
// get the last packet size set on the camera
PvAttrUint32Get(lHandle,"PacketSize",&lMaxSize);
// adjust the packet size according to the current network capacity
PvCaptureAdjustPacketSize(lHandle,lMaxSize);
aMaster = true;
}
return lHandle;
}
//
// idlPvCameraOpen
//
// Open a camera
//
// command line arguments
// argv[0]: IN/FLAG debug
// argv[1]: IN index of camera to be opened
// argv[2]: IN accessflag: 0 for listen-only, 1 for master
int idlPvCameraOpen (int argc, char *argv[])
{
unsigned long n;
unsigned long accessflag;
unsigned long err;
debug = *(IDL_INT *) argv[0];
n = *(unsigned long *) argv[1];
accessflag = *(unsigned long *) argv[2];
CHECKINDEX(n);
err = PvCameraOpen(info[n].UniqueId,
(accessflag) ? ePvAccessMaster : ePvAccessMonitor,
&camera[n]);
return idlPvErrCode(err);
}
// open camera, allocate memory
// return value: true == success, false == fail
bool CameraSetup()
{
tPvErr errCode;
bool failed = false;
unsigned long FrameSize = 0;
// open camera
if ((errCode = PvCameraOpen(GCamera.UID,ePvAccessMaster,&(GCamera.Handle))) != ePvErrSuccess)
{
if (errCode == ePvErrAccessDenied)
printf("PvCameraOpen returned ePvErrAccessDenied:\nCamera already open, or not properly closed.\n");
else
printf("PvCameraOpen err: %u\n", errCode);
return false;
}
// Calculate frame buffer size
if((errCode = PvAttrUint32Get(GCamera.Handle,"TotalBytesPerFrame",&FrameSize)) != ePvErrSuccess)
{
printf("CameraSetup: Get TotalBytesPerFrame err: %u\n", errCode);
return false;
}
// allocate the frame buffers
for(int i=0;i<FRAMESCOUNT && !failed;i++)
{
GCamera.Frames[i].ImageBuffer = new char[FrameSize];
if(GCamera.Frames[i].ImageBuffer)
{
GCamera.Frames[i].ImageBufferSize = FrameSize;
}
else
{
printf("CameraSetup: Failed to allocate buffers.\n");
failed = true;
}
}
return !failed;
}
// open the camera
bool CameraSetup(tCamera* Camera)
{
return !PvCameraOpen(Camera->UID,ePvAccessMaster,&(Camera->Handle));
}
// Initialize camera input
bool CvCaptureCAM_PvAPI::open( int index )
{
tPvCameraInfo cameraList[MAX_CAMERAS];
tPvCameraInfo camInfo;
tPvIpSettings ipSettings;
if (PvInitialize()) {
}
//return false;
Sleep(1000);
//close();
int numCameras=PvCameraList(cameraList, MAX_CAMERAS, NULL);
if (numCameras <= 0 || index >= numCameras)
return false;
Camera.UID = cameraList[index].UniqueId;
if (!PvCameraInfo(Camera.UID,&camInfo) && !PvCameraIpSettingsGet(Camera.UID,&ipSettings)) {
/*
struct in_addr addr;
addr.s_addr = ipSettings.CurrentIpAddress;
printf("Current address:\t%s\n",inet_ntoa(addr));
addr.s_addr = ipSettings.CurrentIpSubnet;
printf("Current subnet:\t\t%s\n",inet_ntoa(addr));
addr.s_addr = ipSettings.CurrentIpGateway;
printf("Current gateway:\t%s\n",inet_ntoa(addr));
*/
}
else {
fprintf(stderr,"ERROR: could not retrieve camera IP settings.\n");
return false;
}
if (PvCameraOpen(Camera.UID, ePvAccessMaster, &(Camera.Handle))==ePvErrSuccess)
{
//Set Pixel Format to BRG24 to follow conventions
/*Errcode = PvAttrEnumSet(Camera.Handle, "PixelFormat", "Bgr24");
if (Errcode != ePvErrSuccess)
{
fprintf(stderr, "PvAPI: couldn't set PixelFormat to Bgr24\n");
return NULL;
}
*/
tPvUint32 frameWidth, frameHeight, frameSize;
unsigned long maxSize;
char pixelFormat[256];
PvAttrUint32Get(Camera.Handle, "TotalBytesPerFrame", &frameSize);
PvAttrUint32Get(Camera.Handle, "Width", &frameWidth);
PvAttrUint32Get(Camera.Handle, "Height", &frameHeight);
PvAttrEnumGet(Camera.Handle, "PixelFormat", pixelFormat,256,NULL);
maxSize = 8228;
//PvAttrUint32Get(Camera.Handle,"PacketSize",&maxSize);
if (PvCaptureAdjustPacketSize(Camera.Handle,maxSize)!=ePvErrSuccess)
return false;
if (strcmp(pixelFormat, "Mono8")==0) {
grayframe = cvCreateImage(cvSize((int)frameWidth, (int)frameHeight), IPL_DEPTH_8U, 1);
grayframe->widthStep = (int)frameWidth;
frame = cvCreateImage(cvSize((int)frameWidth, (int)frameHeight), IPL_DEPTH_8U, 3);
frame->widthStep = (int)frameWidth*3;
Camera.Frame.ImageBufferSize = frameSize;
Camera.Frame.ImageBuffer = grayframe->imageData;
}
else if (strcmp(pixelFormat, "Mono16")==0) {
grayframe = cvCreateImage(cvSize((int)frameWidth, (int)frameHeight), IPL_DEPTH_16U, 1);
grayframe->widthStep = (int)frameWidth;
frame = cvCreateImage(cvSize((int)frameWidth, (int)frameHeight), IPL_DEPTH_16U, 3);
frame->widthStep = (int)frameWidth*3;
Camera.Frame.ImageBufferSize = frameSize;
Camera.Frame.ImageBuffer = grayframe->imageData;
}
else if (strcmp(pixelFormat, "Bgr24")==0) {
frame = cvCreateImage(cvSize((int)frameWidth, (int)frameHeight), IPL_DEPTH_8U, 3);
frame->widthStep = (int)frameWidth*3;
Camera.Frame.ImageBufferSize = frameSize;
Camera.Frame.ImageBuffer = frame->imageData;
}
else
return false;
// Start the camera
PvCaptureStart(Camera.Handle);
// Set the camera to capture continuously
if(PvAttrEnumSet(Camera.Handle, "AcquisitionMode", "Continuous")!= ePvErrSuccess)
{
fprintf(stderr,"Could not set Prosilica Acquisition Mode\n");
return false;
}
if(PvCommandRun(Camera.Handle, "AcquisitionStart")!= ePvErrSuccess)
{
fprintf(stderr,"Could not start Prosilica acquisition\n");
return false;
}
if(PvAttrEnumSet(Camera.Handle, "FrameStartTriggerMode", "Freerun")!= ePvErrSuccess)
{
fprintf(stderr,"Error setting Prosilica trigger to \"Freerun\"");
return false;
}
return true;
}
fprintf(stderr,"Error cannot open camera\n");
return false;
}
int main(int argc, char* argv[])
{
int err = 0;
// initialise the Prosilica API
if(!PvInitialize())
{
int c;
unsigned long uid = 0;
unsigned long addr = 0;
bool bLoad = false;
bool bSave = false;
while ((c = getopt (argc, argv, "u:i:ls:h?")) != -1)
{
switch(c)
{
case 'u':
{
if(optarg)
uid = atol(optarg);
break;
}
case 'i':
{
if(optarg)
addr = inet_addr(optarg);
break;
}
case 'l':
{
bLoad = true;
break;
}
case 's':
{
bSave = true;
break;
}
case '?':
case 'h':
{
ShowUsage();
break;
}
default:
break;
}
}
if((uid || addr) && (bSave || bLoad))
{
tPvHandle Camera;
tPvAccessFlags Flags = (bLoad ? ePvAccessMaster : ePvAccessMonitor);
tPvErr Err;
bool Done = false;
if(uid)
{
// wait a bit to leave some time to the API to detect any camera
Sleep(500);
// and open the camera
Err = PvCameraOpen(uid,Flags,&Camera);
}
else
Err = PvCameraOpenByAddr(addr,Flags,&Camera);
if(!Err)
{
if(bLoad) // load the camera setup
Done = SetupLoad(Camera,argv[argc-1]);
else
if(bSave) // save the camera setup
Done = SetupSave(Camera,argv[argc-1]);
if(!Done)
fprintf(stderr,"sorry, an error occured\n");
err = 1;
// close the camera
PvCameraClose(Camera);
}
else
{
if(Err == ePvErrNotFound || Err == ePvErrUnplugged)
fprintf(stderr,"sorry, couldn't found the camera\n");
else
if(Err == ePvErrAccessDenied)
fprintf(stderr,"sorry, this camera is already in use\n");
else
fprintf(stderr,"sorry, couldn't open the camera for some reason\n");
err = 1;
}
}
else
{
ShowUsage();
err = 1;
}
// uninitialise the API
PvUnInitialize();
}
else
{
err = 1;
fprintf(stderr,"failed to initialise the API\n");
}
return err;
}
// open the camera
bool CameraSetup()
{
return !PvCameraOpen(GCamera.UID,ePvAccessMaster,&(GCamera.Handle));
}
int main(int argc, char* argv[])
{
tPvErr errCode;
int err = 0;
// initialize the PvAPI
if((errCode = PvInitialize()) != ePvErrSuccess)
{
printf("PvInitialize err: %u\n", errCode);
}
else
{
int c;
unsigned long uid = 0;
unsigned long addr = 0;
bool bGet = false;
bool bSet = false;
while ((c = getopt (argc, argv, "u:i:gs:h?")) != -1)
{
switch(c)
{
case 'u':
{
if(optarg)
uid = atol(optarg);
break;
}
case 'i':
{
if(optarg)
addr = inet_addr(optarg);
break;
}
case 'g':
{
bGet = true;
break;
}
case 's':
{
bSet = true;
break;
}
case '?':
case 'h':
{
ShowUsage();
break;
}
default:
break;
}
}
if(uid || ((addr != INADDR_NONE) && (addr != INADDR_ANY)))
{
tPvHandle Camera;
tPvAccessFlags Flags = (bSet ? ePvAccessMaster : ePvAccessMonitor);
if(uid)
{
// wait a bit to leave some time to the API to detect any camera
Sleep(500);
// and open the camera
errCode = PvCameraOpen(uid,Flags,&Camera);
}
else
errCode = PvCameraOpenByAddr(addr,Flags,&Camera);
if(errCode == ePvErrSuccess)
{
if(bGet) // get value
errCode = MemRead(Camera);
else if(bSet) // set value
errCode = MemWrite(Camera,argv[argc-1]);
if(errCode != ePvErrSuccess)
fprintf(stderr,"Error: %u\n",errCode);
err = 1;
// close the camera
PvCameraClose(Camera);
}
else
{
if(errCode == ePvErrNotFound || errCode == ePvErrUnplugged)
fprintf(stderr,"No camera detected.\n");
else if(errCode == ePvErrAccessDenied)
fprintf(stderr,"Camera already in use.\n");
else
fprintf(stderr,"PvCameraOpen fail: %u\n", errCode);
err = 1;
}
}
else
{
ShowUsage();
err = 1;
}
PvUnInitialize();
}
return err;
}
bool CameraGigE::onInit() {
LOG(LTRACE) << "CameraGigE::initialize\n";
h_onTrigger.setup(this, &CameraGigE::onTrigger);
registerHandler("onTrigger", &h_onTrigger);
newImage = registerEvent("newImage");
endOfSequence = registerEvent("endOfSequence");
registerStream("out_img", &out_img);
if (!props.address.empty()) {
unsigned long ip = inet_addr(props.address.c_str());
if (PvCameraOpenByAddr(ip, ePvAccessMaster, &cHandle) != ePvErrSuccess) {
LOG(LERROR) << "Unable to open camera on adress "
<< props.address << " \n";
return false;
}
} else if (props.uid != 0) {
if (PvCameraOpen(props.uid, ePvAccessMaster, &cHandle) != ePvErrSuccess) {
LOG(LERROR) << "Unable to open camera with uid " << props.uid
<< " \n";
return false;
}
} else {
return false;
}
// Set parameters
tPvErr err;
/// Exposure
if (!props.exposureMode.empty()) {
if ((err = PvAttrEnumSet(cHandle, "ExposureMode",
props.exposureMode.c_str())) == ePvErrSuccess) {
if (props.exposureMode == "Manual") {
if ((err = PvAttrUint32Set(cHandle, "ExposureValue",
props.exposureValue / 1000000.0)) != ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "ExposureValue", &min, &max);
LOG(LWARNING) << "ExposureValue : "
<< props.exposureValue
<< " is out of range, valid range [ "
<< (double) min / 1000000.0 << " , "
<< (double) max / 1000000.0 << " ]\n";
}
}
}
} else {
LOG(LWARNING) << "Unable to set ExposureMode \n";
}
}
/// Gain
if (!props.gainMode.empty()) {
if ((err = PvAttrEnumSet(cHandle, "GainMode", props.gainMode.c_str()))
== ePvErrSuccess) {
if (props.gainMode == "Manual") {
if ((err = PvAttrUint32Set(cHandle, "gainValue",
props.gainValue)) != ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "GainValue", &min, &max);
LOG(LWARNING) << "GainValue : " << props.gainValue
<< " is out of range, valid range [ "
<< (double) min << " , " << (double) max
<< " ]\n";
}
}
}
} else {
LOG(LWARNING) << "Unable to set GainMode \n";
}
}
/// White Balance
if (!props.whitebalMode.empty()) {
if ((err = PvAttrEnumSet(cHandle, "WhitebalMode",
props.gainMode.c_str())) == ePvErrSuccess) {
if (props.whitebalMode == "Manual") {
if ((err = PvAttrUint32Set(cHandle, "WhitebalValueRed",
props.whitebalValueRed)) != ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "WhitebalValueRed", &min,
&max);
LOG(LWARNING) << "WhitebalValueRed : "
<< props.whitebalValueRed
<< " is out of range, valid range [ "
<< (double) min << " , " << (double) max
<< " ]\n";
}
}
if ((err = PvAttrUint32Set(cHandle, "WhitebalValueBlue",
props.whitebalValueBlue)) != ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "WhitebalValueBlue", &min,
&max);
LOG(LWARNING) << "WhitebalValueBlue : "
<< props.whitebalValueBlue
<< " is out of range, valid range [ "
<< (double) min << " , " << (double) max
<< " ]\n";
}
}
}
} else {
LOG(LWARNING) << "Unable to set WhitebalMode" << err << "\n";
}
}
if ((err = PvAttrEnumSet(cHandle, "MirrorX", props.mirrorX ? "On" : "Off"))
!= ePvErrSuccess) {
}
if ((err = PvAttrEnumSet(cHandle, "PixelFormat", props.pixelFormat.c_str()))
!= ePvErrSuccess) {
LOG(LERROR) << "Unable to set pixelformat " << err;
}
if ((err = PvAttrUint32Set(cHandle, "Height", props.height))
!= ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "Height", &min, &max);
LOG(LWARNING) << "Height : " << props.height
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]";
}
}
if ((err = PvAttrUint32Set(cHandle, "Width", props.width)) != ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "Width", &min, &max);
LOG(LWARNING) << "Width : " << props.width
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]\n";
}
}
if ((err = PvAttrUint32Set(cHandle, "RegionX", props.regionX))
!= ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "RegionX", &min, &max);
LOG(LWARNING) << "RegionX : " << props.regionX
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]\n";
}
}
if ((err = PvAttrUint32Set(cHandle, "RegionY", props.regionY))
!= ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "RegionY", &min, &max);
LOG(LWARNING) << "RegionY : " << props.regionY
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]\n";
}
}
if ((err = PvAttrUint32Set(cHandle, "BinningX", props.binningX))
!= ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "BinningX", &min, &max);
LOG(LWARNING) << "BinningX : " << props.binningX
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]\n";
}
}
if ((err = PvAttrUint32Set(cHandle, "BinningY", props.binningY))
!= ePvErrSuccess) {
if (err == ePvErrOutOfRange) {
tPvUint32 min, max;
PvAttrRangeUint32(cHandle, "BinningY", &min, &max);
LOG(LWARNING) << "BinningY : " << props.binningY
<< " is out of range, valid range [ " << (double) min
<< " , " << (double) max << " ]\n";
}
}
// ----------------
PvAttrEnumSet(cHandle, "FrameStartTriggerMode", "Freerun");
unsigned long frameSize = 0;
if (PvAttrUint32Get(cHandle, "TotalBytesPerFrame", &frameSize)
!= ePvErrSuccess) {
return false;
}
frame.ImageBuffer = new char[frameSize];
frame.ImageBufferSize = frameSize;
return true;
}
// Initialize camera input
bool CvCaptureCAM_PvAPI::open( int index )
{
tPvCameraInfo cameraList[MAX_CAMERAS];
tPvCameraInfo camInfo;
tPvIpSettings ipSettings;
if (PvInitialize()) {
}
//return false;
Sleep(1000);
//close();
int numCameras=PvCameraList(cameraList, MAX_CAMERAS, NULL);
if (numCameras <= 0 || index >= numCameras)
return false;
Camera.UID = cameraList[index].UniqueId;
if (!PvCameraInfo(Camera.UID,&camInfo) && !PvCameraIpSettingsGet(Camera.UID,&ipSettings))
{
/*
struct in_addr addr;
addr.s_addr = ipSettings.CurrentIpAddress;
printf("Current address:\t%s\n",inet_ntoa(addr));
addr.s_addr = ipSettings.CurrentIpSubnet;
printf("Current subnet:\t\t%s\n",inet_ntoa(addr));
addr.s_addr = ipSettings.CurrentIpGateway;
printf("Current gateway:\t%s\n",inet_ntoa(addr));
*/
}
else
{
fprintf(stderr,"ERROR: could not retrieve camera IP settings.\n");
return false;
}
if (PvCameraOpen(Camera.UID, ePvAccessMaster, &(Camera.Handle))==ePvErrSuccess)
{
tPvUint32 frameWidth, frameHeight;
unsigned long maxSize;
// By Default, try to set the pixel format to Mono8. This can be changed later
// via calls to setProperty. Some colour cameras (i.e. the Manta line) have a default
// image mode of Bayer8, which is currently unsupported, so Mono8 is a safe bet for
// startup.
monocrome = (PvAttrEnumSet(Camera.Handle, "PixelFormat", "Mono8") == ePvErrSuccess);
PvAttrUint32Get(Camera.Handle, "Width", &frameWidth);
PvAttrUint32Get(Camera.Handle, "Height", &frameHeight);
// Determine the maximum packet size supported by the system (ethernet adapter)
// and then configure the camera to use this value. If the system's NIC only supports
// an MTU of 1500 or lower, this will automatically configure an MTU of 1500.
// 8228 is the optimal size described by the API in order to enable jumbo frames
maxSize = 8228;
//PvAttrUint32Get(Camera.Handle,"PacketSize",&maxSize);
if (PvCaptureAdjustPacketSize(Camera.Handle,maxSize)!=ePvErrSuccess)
return false;
resizeCaptureFrame(frameWidth, frameHeight);
return startCapture();
}
fprintf(stderr,"Error cannot open camera\n");
return false;
}
// Initialize camera input
bool CvCaptureCAM_PvAPI::open( int index )
{
tPvCameraInfo cameraInfo[MAX_CAMERAS];
if (PvInitialize())
return false;
usleep(250000);
//close();
int numCameras = PvCameraList(cameraInfo, MAX_CAMERAS, NULL);
if (numCameras <= 0 || index >= numCameras)
return false;
Camera.UID = cameraInfo[index].UniqueId;
if (PvCameraOpen(Camera.UID, ePvAccessMaster, &(Camera.Handle))==ePvErrSuccess)
{
//Set Pixel Format to BRG24 to follow conventions
Errcode = PvAttrEnumSet(Camera.Handle, "PixelFormat", "Bgr24");
if (Errcode != ePvErrSuccess)
{
fprintf(stderr, "PvAPI: couldn't set PixelFormat to Bgr24\n");
return NULL;
}
tPvUint32 frameWidth, frameHeight, frameSize;
PvAttrUint32Get(Camera.Handle, "TotalBytesPerFrame", &frameSize);
PvAttrUint32Get(Camera.Handle, "Width", &frameWidth);
PvAttrUint32Get(Camera.Handle, "Height", &frameHeight);
// Create an image (24 bits RGB Color image)
frame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 3);
frame->widthStep = frameWidth*3;
Camera.Frame.ImageBufferSize = frameSize;
Camera.Frame.ImageBuffer = frame->imageData;
// Start the camera
PvCaptureStart(Camera.Handle);
// Set the camera to capture continuously
if(PvAttrEnumSet(Camera.Handle, "AcquisitionMode", "Continuous")!= ePvErrSuccess)
{
fprintf(stderr,"Could not set Prosilica Acquisition Mode\n");
return false;
}
if(PvCommandRun(Camera.Handle, "AcquisitionStart")!= ePvErrSuccess)
{
fprintf(stderr,"Could not start Prosilica acquisition\n");
return false;
}
if(PvAttrEnumSet(Camera.Handle, "FrameStartTriggerMode", "Freerun")!= ePvErrSuccess)
{
fprintf(stderr,"Error setting Prosilica trigger to \"Freerun\"");
return false;
}
return true;
}
return false;
}
//--------------------------------------------------------------------
bool ofxVideoGrabberPvAPI::initGrabber(int w, int h, bool setUseTexture){
width = w;
height = h;
tPvErr ret; //PvAPI return codes
bUseTexture = setUseTexture;
memset( &cameraUID, 0, sizeof(cameraUID) );
memset( &cameraHandle, 0, sizeof(cameraHandle) );
memset( &cameraFrame, 0, sizeof(cameraFrame) );
//---------------------------------- 1 - open the sequence grabber
// lazy initialization of the Prosilica API
if( !bPvApiInitiated ){
ret = PvInitialize();
if( ret == ePvErrSuccess ) {
ofLog(OF_LOG_VERBOSE, "PvAPI initialized");
} else {
ofLog(OF_LOG_ERROR, "unable to initialize PvAPI");
return false;
}
bPvApiInitiated = true;
}
//---------------------------------- 3 - buffer allocation
// Create a buffer big enough to hold the video data,
// make sure the pointer is 32-byte aligned.
// also the rgb image that people will grab
pixels = new unsigned char[width*height];
// check for any cameras plugged in
int waitIterations = 0;
while( PvCameraCount() < 1 ) {
ofSleepMillis(250);
waitIterations++;
if( waitIterations > 8 ) {
ofLog(OF_LOG_ERROR, "error: no camera found");
return false;
}
}
//---------------------------------- 4 - device selection
tPvUint32 count, connected;
tPvCameraInfo list[maxConcurrentCams];
count = PvCameraList( list, maxConcurrentCams, &connected );
if(count >= 1) {
bool bSelectedDevicePresent = false;
if(bChooseDevice) {
//check if selected device is available
for( int i=0; i<count; ++i) {
if( deviceID == list[i].UniqueId ) {
bSelectedDevicePresent = true;
cameraUID = list[i].UniqueId;
}
}
}
if( !bSelectedDevicePresent ){
cameraUID = list[0].UniqueId;
ofLog(OF_LOG_NOTICE, "cannot find selected camera -> defaulting to first available");
ofLog(OF_LOG_VERBOSE, "there is currently an arbitrary hard limit of %i concurrent cams", maxConcurrentCams);
}
} else {
ofLog(OF_LOG_ERROR, "no cameras available");
return false;
}
//---------------------------------- 5 - final initialization steps
ret = PvCameraOpen( cameraUID, ePvAccessMaster, &cameraHandle );
if( ret == ePvErrSuccess ){
ofLog(OF_LOG_VERBOSE, "camera opened");
} else {
if( ret == ePvErrAccessDenied ) {
ofLog(OF_LOG_ERROR, "camera access denied, probably already in use");
}
ofLog(OF_LOG_ERROR, "failed to open camera");
return false;
}
unsigned long FrameSize = 0;
ret = PvAttrUint32Get( cameraHandle, "TotalBytesPerFrame", &FrameSize );
if( ret == ePvErrSuccess ){
// allocate the buffer for the single frame we need
cameraFrame.ImageBuffer = new char[FrameSize];
cameraFrame.ImageBufferSize = FrameSize;
ofLog(OF_LOG_VERBOSE, "camera asked for TotalBytesPerFrame");
} else {
ofLog(OF_LOG_ERROR, "failed to allocate capture buffer");
return false;
}
ret = PvCaptureStart(cameraHandle);
if( ret == ePvErrSuccess ){
ofLog(OF_LOG_VERBOSE, "camera set to capture mode");
} else {
if( ret == ePvErrUnplugged ){
ofLog(OF_LOG_ERROR, "cannot start capture, camera was unplugged");
}
ofLog(OF_LOG_ERROR, "cannot set to capture mode");
return false;
}
ret = PvAttrEnumSet(cameraHandle,"FrameStartTriggerMode","Freerun");
if( ret == ePvErrSuccess ){
ofLog(OF_LOG_VERBOSE, "camera set to continuous mode");
} else {
ofLog(OF_LOG_ERROR, "cannot set to continous mode");
return false;
}
ret = PvCommandRun(cameraHandle,"AcquisitionStart");
if( ret == ePvErrSuccess ){
ofLog(OF_LOG_VERBOSE, "camera continuous acquisition started");
} else {
// if that fail, we reset the camera to non capture mode
PvCaptureEnd(cameraHandle) ;
ofLog(OF_LOG_ERROR, "cannot start continuous acquisition");
return false;
}
bGrabberInited = true;
//loadSettings();
ofLog(OF_LOG_NOTICE,"camera is ready now");
//---------------------------------- 6 - setup texture if needed
if (bUseTexture){
// create the texture, set the pixels to black and
// upload them to the texture (so at least we see nothing black the callback)
tex.allocate(width,height,GL_LUMINANCE);
memset(pixels, 0, width*height);
tex.loadData(pixels, width, height, GL_LUMINANCE);
}
// we are done
return true;
}
