void of1394VideoGrabber::setAutoExposure(bool a){
if(!a){
dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL);
}
else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_AUTO);
}
}
void of1394VideoGrabber::setAutoShutter(bool a){
if(!a){
dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
}
else {
dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_AUTO);
}
}
void DC1394Camera::setWhiteBalance(uint32_t uValue, uint32_t vValue,
bool makeAuto)
{
// Grab the white balance feature
dc1394feature_info_t whiteBalance;
whiteBalance.id = DC1394_FEATURE_WHITE_BALANCE;
if (makeAuto) {
LOGGER.infoStream() << m_guid << ": Setting white balance automatically";
} else {
LOGGER.infoStream() << m_guid << ": Setting white balance to "
<< "U Value: " << uValue << " "
<< "V Value: " << vValue;
}
dc1394error_t err = dc1394_feature_get(m_camera, &whiteBalance);
assert(DC1394_SUCCESS == err && "Could not get white balance feature info");
// Make sure its available
assert((whiteBalance.available == DC1394_TRUE) &&
"White balance not supported by camera");
if (makeAuto)
{
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_AUTO);
assert(DC1394_SUCCESS == err && "Could not set whitebalance to auto");
}
else
{
// Set manual mode
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_MANUAL);
assert(DC1394_SUCCESS == err && "Could not set whitebalance to manual");
// Store the values
uint32_t whiteMax = whiteBalance.max;
uint32_t whiteMin = whiteBalance.min;
// Error on out of bounds values
if (((uValue > whiteMax) || (uValue < whiteMin)) ||
((vValue > whiteMax) || (vValue < whiteMin)))
{
fprintf(stderr, "ERROR: WhiteBalance out of bounds: (%u, %u)\n",
whiteMin, whiteMax);
assert(false && "White balance out of bounds");
}
// Set values
err = dc1394_feature_whitebalance_set_value(m_camera, uValue, vValue);
assert(DC1394_SUCCESS == err && "Could not set whitebalance");
}
LOGGER.infoStream() << m_guid << ": Successfully set white balance";
}
void DC1394Camera::setExposure(uint32_t value, bool makeAuto)
{
// Grab the white balance feature
dc1394feature_info_t exposure;
exposure.id = DC1394_FEATURE_EXPOSURE;
if (makeAuto) {
LOGGER.infoStream() << m_guid << ": Setting exposure automatically";
} else {
LOGGER.infoStream() << m_guid << ": Setting exposure to " << value;
}
dc1394error_t err = dc1394_feature_get(m_camera, &exposure);
assert(DC1394_SUCCESS == err && "Could not get exposure feature info");
// Make sure its available
assert((exposure.available == DC1394_TRUE) &&
"Exposure not supported by camera");
if (makeAuto)
{
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_EXPOSURE,
DC1394_FEATURE_MODE_AUTO);
assert(DC1394_SUCCESS == err && "Could not set exposure to auto");
}
else
{
// Set manual mode
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_EXPOSURE,
DC1394_FEATURE_MODE_MANUAL);
assert(DC1394_SUCCESS == err && "Could not set exposure to manual");
// Error on out of bounds values
if ((value > exposure.max) || (value < exposure.min))
{
fprintf(stderr, "ERROR: Exposure is out of bounds: (%u, %u)\n",
exposure.min, exposure.max);
assert(false && "Exposure out of bounds");
}
// Set value
err = dc1394_feature_set_value(m_camera, DC1394_FEATURE_EXPOSURE,
value);
assert(DC1394_SUCCESS == err && "Could not set exposure");
}
LOGGER.infoStream() << m_guid << ": Successfully set exposure";
}
void DC1394Camera::setBrightness(uint32_t value, bool makeAuto)
{
// Grab the white balance feature
dc1394feature_info_t brightness;
brightness.id = DC1394_FEATURE_BRIGHTNESS;
if (makeAuto) {
LOGGER.infoStream() << m_guid << ": Setting brightness automatically";
} else {
LOGGER.infoStream() << m_guid << ": Setting brightness to " << value;
}
dc1394error_t err = dc1394_feature_get(m_camera, &brightness);
assert(DC1394_SUCCESS == err && "Could not get brightness feature info");
// Make sure its available
assert((brightness.available == DC1394_TRUE) &&
"Brightness not supported by camera");
if (makeAuto)
{
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_BRIGHTNESS,
DC1394_FEATURE_MODE_AUTO);
assert(DC1394_SUCCESS == err && "Could not set brightness to auto");
}
else
{
// Set manual mode
err = dc1394_feature_set_mode(m_camera, DC1394_FEATURE_BRIGHTNESS,
DC1394_FEATURE_MODE_MANUAL);
assert(DC1394_SUCCESS == err && "Could not set brightness to manual");
// Error on out of bounds values
if ((value > brightness.max) || (value < brightness.min))
{
fprintf(stderr, "ERROR: Brightness is out of bounds: (%u, %u)\n",
brightness.min, brightness.max);
assert(false && "Brightness out of bounds");
}
// Set value
err = dc1394_feature_set_value(m_camera, DC1394_FEATURE_BRIGHTNESS,
value);
assert(DC1394_SUCCESS == err && "Could not set brightness");
}
LOGGER.infoStream() << m_guid << ": Successfully set brightness";
}
/** Set mode for a feature.
*
* @pre feature_set_ initialized for this camera
*
* @param finfo pointer to information for this feature
* @param mode DC1394 mode desired
* @return true if mode set successfully
*/
bool Features::setMode(dc1394feature_info_t *finfo, dc1394feature_mode_t mode)
{
dc1394feature_t feature = finfo->id;
if (hasMode(finfo, mode))
{
// first, make sure the feature is powered on
setPower(finfo, DC1394_ON);
ROS_DEBUG_STREAM("setting feature " << featureName(feature)
<< " mode to " << modeName(mode));
if (DC1394_SUCCESS !=
dc1394_feature_set_mode(camera_, feature, mode))
{
ROS_WARN_STREAM("failed to set feature " << featureName(feature)
<< " mode to " << modeName(mode));
return false;
}
}
else
{
// device does not support this mode for this feature
ROS_DEBUG_STREAM("no " << modeName(mode)
<< " mode for feature " << featureName(feature));
return false;
}
return true;
}
void ofxLibdc::setFeatureNorm(dc1394feature_t feature, float value) {
unsigned int min, max;
getFeatureRange(feature, &min, &max);
dc1394_feature_set_power(camera, feature, DC1394_ON);
dc1394_feature_set_mode(camera, feature, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_value(camera, feature, value * (max - min) + min);
}
void FirewireVideo::SetAutoShutterTime(){
dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_AUTO);
if (err < 0) {
throw VideoException("Could not set auto shutter mode");
}
}
void FirewireVideo::SetAutoGain(){
dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_AUTO);
if (err < 0) {
throw VideoException("Could not set auto gain mode");
}
}
void Libdc1394SequenceGrabber::setFeature(dc1394feature_t feature, float value)
{
if (!_camera) return;
dc1394bool_t is_present;
dc1394error_t err;
dc1394_feature_is_present(_camera, feature, &is_present);
if (is_present == DC1394_FALSE)
return;
dc1394feature_mode_t current_mode = (value == -1.0) ? DC1394_FEATURE_MODE_AUTO : DC1394_FEATURE_MODE_MANUAL;
err = dc1394_feature_set_mode(_camera, feature, current_mode);
checkSuccess(err, "dc1394_feature_set_mode failed");
if (value == -1.0)
return;
uint32_t min, max, int_value;
dc1394_feature_get_boundaries(_camera, feature, &min, &max);
int_value = min + value / 1000.0 * (max-min);
// std::cout << feature << " value: " << int_value << " min: " << min << " max: " << max << std::endl;
err = dc1394_feature_set_value(_camera, feature, int_value);
checkSuccess(err, "dc1394_feature_set_value failed");
}
void FWCamera::setFeatureOneShot(CameraFeature feature)
{
#ifdef AVG_ENABLE_1394_2
dc1394feature_t featureID = getFeatureID(feature);
dc1394error_t err = dc1394_feature_set_mode(m_pCamera, featureID,
DC1394_FEATURE_MODE_ONE_PUSH_AUTO);
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: Unable to set one-shot for "
<< cameraFeatureToString(feature) << ". Error was " << err);
}
#endif
}
int ar2VideoSetAutoOn1394(AR2VideoParam1394T *vid, int paramName, int value)
{
dc1394feature_t feature;
dc1394feature_mode_t mode;
int v;
switch (paramName)
{
case AR_VIDEO_1394_BRIGHTNESS:
feature = DC1394_FEATURE_BRIGHTNESS;
break;
case AR_VIDEO_1394_EXPOSURE:
feature = DC1394_FEATURE_EXPOSURE;
break;
case AR_VIDEO_1394_WHITE_BALANCE:
feature = DC1394_FEATURE_WHITE_BALANCE;
break;
case AR_VIDEO_1394_SHUTTER_SPEED:
feature = DC1394_FEATURE_SHUTTER;
break;
case AR_VIDEO_1394_GAIN:
feature = DC1394_FEATURE_GAIN;
break;
case AR_VIDEO_1394_FOCUS:
feature = DC1394_FEATURE_FOCUS;
break;
case AR_VIDEO_1394_GAMMA:
feature = DC1394_FEATURE_GAMMA;
break;
default:
return -1;
}
if (value)
mode = DC1394_FEATURE_MODE_AUTO;
else
mode = DC1394_FEATURE_MODE_MANUAL;
if (dc1394_feature_set_mode(vid->camera, feature, mode) != DC1394_SUCCESS)
{
ARLOGe("unable to set mode.\n");
return -1;
}
return 0;
}
void FWCamera::setWhitebalance(int u, int v, bool bIgnoreOldValue)
{
#ifdef AVG_ENABLE_1394_2
if (hasFeature(CAM_FEATURE_WHITE_BALANCE)) {
if (bIgnoreOldValue || u != m_WhitebalanceU || v != m_WhitebalanceV) {
m_WhitebalanceU = u;
m_WhitebalanceV = v;
dc1394error_t err;
if (u == -1) {
err = dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_AUTO);
} else {
err = dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_WHITE_BALANCE,
DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_whitebalance_set_value(m_pCamera, u, v);
}
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: Unable to set whitebalance. Error was " << err);
}
}
}
#endif
}
void FWCamera::setFeature(dc1394feature_t feature, int value)
{
#ifdef AVG_ENABLE_1394_2
dc1394error_t err;
if (value == -1) {
err = dc1394_feature_set_mode(m_pCamera, feature, DC1394_FEATURE_MODE_AUTO);
err = dc1394_feature_set_power(m_pCamera, feature, DC1394_OFF);
} else {
dc1394_feature_set_mode(m_pCamera, feature, DC1394_FEATURE_MODE_MANUAL);
err = dc1394_feature_set_power(m_pCamera, feature, DC1394_ON);
err = dc1394_feature_set_value(m_pCamera, feature, value);
}
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: Unable to set " << feature << ". Error was " << err);
}
/*
dc1394feature_info_t featureInfo;
featureInfo.id = feature;
err = dc1394_feature_get(m_pCamera, &featureInfo);
dc1394_feature_print(&featureInfo, stdout);
*/
#endif
}
bool
VideoIIDC1394::doOneShotFocus()
{
#if defined(DUNE_WITH_DC1394)
dc1394error_t error_code;
error_code = dc1394_feature_set_mode(camera, DC1394_FEATURE_FOCUS, DC1394_FEATURE_MODE_ONE_PUSH_AUTO);
if (error_code < 0)
{
throw std::runtime_error("Could not capture a frame");
}
return true;
#else
return false;
#endif
}
void FirewireVideo::SetGain(float val){
dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
if (err < 0) {
throw VideoException("Could not set manual gain mode");
}
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_GAIN, DC1394_ON);
if (err < 0) {
throw VideoException("Could not set absolute control for gain");
}
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_GAIN, val);
if (err < 0) {
throw VideoException("Could not set gain value");
}
}
void FirewireVideo::SetShutterTime(float val){
dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
if (err < 0) {
throw VideoException("Could not set manual shutter mode");
}
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_ON);
if (err < 0) {
throw VideoException("Could not set absolute control for shutter");
}
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, val);
if (err < 0) {
throw VideoException("Could not set shutter value");
}
}
void FWCamera::startCapture()
{
#ifdef AVG_ENABLE_1394_2
int err = dc1394_video_set_transmission(m_pCamera, DC1394_ON);
AVG_ASSERT(err == DC1394_SUCCESS);
dc1394switch_t status = DC1394_OFF;
int i = 0;
while (status == DC1394_OFF && i++ < 5) {
usleep(50000);
err = dc1394_video_get_transmission(m_pCamera, &status);
AVG_ASSERT(err == DC1394_SUCCESS);
}
if (i == 5) {
AVG_ASSERT(false);
}
// Default to turning off any camera sharpness manipulation.
setFeature(CAM_FEATURE_SHARPNESS, 0);
// Turn off possible auto exposure.
dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_EXPOSURE,
DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_power(m_pCamera, DC1394_FEATURE_EXPOSURE, DC1394_OFF);
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Firewire camera opened.");
for (FeatureMap::iterator it=m_Features.begin(); it != m_Features.end(); it++) {
setFeature(it->first, it->second, true);
}
setWhitebalance(m_WhitebalanceU, m_WhitebalanceV, true);
if (getCamPF() == BAYER8) {
if (strcmp(m_pCamera->model, "DFx 31BF03") == 0) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Applying bayer pattern fixup for IS DFx31BF03 camera");
setCamPF(BAYER8_GRBG);
} else if (strcmp(m_pCamera->vendor, "Point Grey Research") == 0) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Applying bayer pattern fixup for PointGrey cameras");
enablePtGreyBayer();
}
}
#endif
}
bool CvCaptureCAM_DC1394_v2_CPP::setProperty(int propId, double value)
{
switch (propId)
{
case CV_CAP_PROP_FRAME_WIDTH:
if(started)
return false;
frameWidth = cvRound(value);
frameHeight = 0;
break;
case CV_CAP_PROP_FRAME_HEIGHT:
if(started)
return false;
frameWidth = 0;
frameHeight = cvRound(value);
break;
case CV_CAP_PROP_FPS:
if(started)
return false;
fps = value;
break;
case CV_CAP_PROP_RECTIFICATION:
if( cameraId != VIDERE )
return false;
rectify = fabs(value) > FLT_EPSILON;
break;
case CV_CAP_PROP_MODE:
if(started)
return false;
userMode = cvRound(value);
break;
case CV_CAP_PROP_ISO_SPEED:
if(started)
return false;
isoSpeed = cvRound(value);
break;
//The code below is based on coriander, callbacks.c:795, refer to case RANGE_MENU_MAN :
default:
if (propId<CV_CAP_PROP_MAX_DC1394 && dc1394properties[propId]!=-1
&& dcCam)
{
//get the corresponding feature from property-id
dc1394feature_info_t *act_feature = &feature_set.feature[dc1394properties[propId]-DC1394_FEATURE_MIN];
if (cvRound(value) == CV_CAP_PROP_DC1394_OFF)
{
if ( (act_feature->on_off_capable)
&& (dc1394_feature_set_power(dcCam, act_feature->id, DC1394_OFF) == DC1394_SUCCESS))
{
act_feature->is_on=DC1394_OFF;
return true;
}
return false;
}
//try to turn the feature ON, feature can be ON and at the same time it can be not capable to change state to OFF
if ( (act_feature->is_on == DC1394_OFF) && (act_feature->on_off_capable == DC1394_TRUE))
{
if (dc1394_feature_set_power(dcCam, act_feature->id, DC1394_ON) == DC1394_SUCCESS)
feature_set.feature[dc1394properties[propId]-DC1394_FEATURE_MIN].is_on=DC1394_ON;
}
//turn off absolute mode - the actual value will be stored in the value field,
//otherwise it would be stored into CSR (control and status register) absolute value
if (act_feature->absolute_capable
&& dc1394_feature_set_absolute_control(dcCam, act_feature->id, DC1394_OFF) !=DC1394_SUCCESS)
return false;
else
act_feature->abs_control=DC1394_OFF;
//set AUTO
if (cvRound(value) == CV_CAP_PROP_DC1394_MODE_AUTO)
{
if (dc1394_feature_set_mode(dcCam, act_feature->id, DC1394_FEATURE_MODE_AUTO)!=DC1394_SUCCESS)
return false;
act_feature->current_mode=DC1394_FEATURE_MODE_AUTO;
return true;
}
//set ONE PUSH
if (cvRound(value) == CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO)
{
//have to set to manual first, otherwise one push will be ignored (AVT manual 4.3.0 p. 115)
if (dc1394_feature_set_mode(dcCam, act_feature->id, DC1394_FEATURE_MODE_ONE_PUSH_AUTO)!=DC1394_SUCCESS)
return false;
//will change to
act_feature->current_mode=DC1394_FEATURE_MODE_ONE_PUSH_AUTO;
return true;
}
//set the feature to MANUAL mode,
if (dc1394_feature_set_mode(dcCam, act_feature->id, DC1394_FEATURE_MODE_MANUAL)!=DC1394_SUCCESS)
return false;
else
act_feature->current_mode=DC1394_FEATURE_MODE_MANUAL;
// if property is one of the white balance features treat it in different way
if (propId == CV_CAP_PROP_WHITE_BALANCE_BLUE_U)
{
if (dc1394_feature_whitebalance_set_value(dcCam,cvRound(value), act_feature->RV_value)!=DC1394_SUCCESS)
return false;
else
{
act_feature->BU_value = cvRound(value);
return true;
}
}
if (propId == CV_CAP_PROP_WHITE_BALANCE_RED_V)
{
if (dc1394_feature_whitebalance_set_value(dcCam, act_feature->BU_value, cvRound(value))!=DC1394_SUCCESS)
return false;
else
{
act_feature->RV_value = cvRound(value);
return true;
}
}
//first: check boundaries
if (value < act_feature->min)
{
value = act_feature->min;
}
else if (value > act_feature->max)
{
value = act_feature->max;
}
if (dc1394_feature_set_value(dcCam, act_feature->id, cvRound(value)) == DC1394_SUCCESS)
{
act_feature->value = value;
return true;
}
}
return false;
}
return true;
}
void of1394VideoGrabber::setTemperature(unsigned int a)
{
dc1394_feature_set_mode(camera, DC1394_FEATURE_TEMPERATURE, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_temperature_set_value(camera, a);
}
void of1394VideoGrabber::setWhiteBalance(unsigned int a, unsigned int b)
{
dc1394_feature_set_mode(camera, DC1394_FEATURE_WHITE_BALANCE, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_whitebalance_set_value(camera, a, b);
}
//--------------------------------------------------------------------
int of1394VideoGrabber::initGrabber()
{
// moved from constructor
int i;
printf("Making new camera\n");
d = dc1394_new ();
err=dc1394_camera_enumerate (d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) {
if(err!=0 && bVerbose)printf("\n No cameras found\n ");
return 1;
}
camera = dc1394_camera_new (d, list->ids[0].guid);
if (!camera) {
if(err!=0 && bVerbose)printf("\n Failed to initialize camera with guid %PRIx64", list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (list);
/*-----------------------------------------------------------------------
* setup capture
*-----------------------------------------------------------------------*/
dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_0);
uint32_t f, f2;
dc1394_format7_get_image_size(camera, DC1394_VIDEO_MODE_FORMAT7_0, &f, &f2);
err=dc1394_capture_setup(camera,4, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera\n");
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
err=dc1394_video_set_transmission(camera, DC1394_ON);
DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not start camera iso transmission\n");
dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height);
if(err != DC1394_SUCCESS){
cout<<"get image size error: "<<err<<endl;
}
printf("Size from video mode = %i wide %i high\n", width, height);
pixels = new unsigned char[width*height*3]; // x3 for RGB
pixels2 = new unsigned char[width*height*3]; // x3 for RGB
tex.allocate(width,height,GL_LUMINANCE);
err = dc1394_capture_dequeue( camera, DC1394_CAPTURE_POLICY_WAIT, &frame ) ;
DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not capture a frame\n");
memcpy( pixels, frame->image, width * height*3) ;
dc1394_capture_enqueue( camera, frame ) ;
ofSleepMillis(10);
startThread(true, false);
failedToInit = false;
dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_mode(camera, DC1394_FEATURE_GAMMA, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_IRIS, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_WHITE_BALANCE, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_TEMPERATURE, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_WHITE_SHADING, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_SATURATION, DC1394_FEATURE_MODE_AUTO);
dc1394_feature_set_mode(camera, DC1394_FEATURE_HUE, DC1394_FEATURE_MODE_AUTO);
//Print features
dc1394_feature_get_all(camera, &features);
dc1394_feature_print_all(&features, stdout);
return 0;
}
/**************************************************************************************
** Client is asking us to establish connection to the device
***************************************************************************************/
bool FFMVCCD::Connect()
{
dc1394camera_list_t *list;
dc1394error_t err;
bool supported;
bool settings_valid;
uint32_t val;
dc1394format7mode_t fm7;
dc1394feature_info_t feature;
float min, max;
dc1394 = dc1394_new();
if (!dc1394) {
return false;
}
err = dc1394_camera_enumerate(dc1394, &list);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not find DC1394 cameras!");
return false;
}
if (!list->num) {
IDMessage(getDeviceName(), "No DC1394 cameras found!");
return false;
}
dcam = dc1394_camera_new(dc1394, list->ids[0].guid);
if (!dcam) {
IDMessage(getDeviceName(), "Unable to connect to camera!");
return false;
}
/* Reset camera */
err = dc1394_camera_reset(dcam);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to reset camera!");
return false;
}
/* Set mode */
err = dc1394_video_set_mode(dcam, DC1394_VIDEO_MODE_640x480_MONO16);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to connect to set videomode!");
return false;
}
/* Disable Auto exposure control */
err = dc1394_feature_set_power(dcam, DC1394_FEATURE_EXPOSURE, DC1394_OFF);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to disable auto exposure control");
return false;
}
/* Set frame rate to the lowest possible */
err = dc1394_video_set_framerate(dcam, DC1394_FRAMERATE_7_5);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to connect to set framerate!");
return false;
}
/* Turn frame rate control off to enable extended exposure (subs of 512ms) */
err = dc1394_feature_set_power(dcam, DC1394_FEATURE_FRAME_RATE, DC1394_OFF);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to disable framerate!");
return false;
}
/* Get the longest possible exposure length */
err = dc1394_feature_set_mode(dcam, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Failed to enable manual shutter control.");
}
err = dc1394_feature_set_absolute_control(dcam, DC1394_FEATURE_SHUTTER, DC1394_ON);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Failed to enable absolute shutter control.");
}
err = dc1394_feature_get_absolute_boundaries(dcam, DC1394_FEATURE_SHUTTER, &min, &max);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not get max shutter length");
} else {
max_exposure = max;
}
/* Set gain to max. By setting the register directly, we can achieve a
* gain of 24 dB...compared to a gain of 12 dB which is reported as the
* max
*/
err = dc1394_set_control_register(dcam, 0x820, 0x40);
//err = dc1394_set_control_register(dcam, 0x820, 0x7f);
if (err != DC1394_SUCCESS) {
return err;
}
#if 0
/* Set absolute gain to max */
err = dc1394_feature_set_absolute_control(dcam, DC1394_FEATURE_GAIN, DC1394_ON);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Failed to enable ansolute gain control.");
}
err = dc1394_feature_get_absolute_boundaries(dcam, DC1394_FEATURE_GAIN, &min, &max);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not get max gain value");
} else {
err = dc1394_feature_set_absolute_value(dcam, DC1394_FEATURE_GAIN, max);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not set max gain value");
}
}
#endif
/* Set brightness */
err = dc1394_feature_set_mode(dcam, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Failed to enable manual brightness control.");
}
err = dc1394_feature_set_absolute_control(dcam, DC1394_FEATURE_BRIGHTNESS, DC1394_ON);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Failed to enable ansolute brightness control.");
}
err = dc1394_feature_set_absolute_value(dcam, DC1394_FEATURE_BRIGHTNESS, 1);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not set max brightness value");
}
/* Turn gamma control off */
err = dc1394_feature_set_absolute_value(dcam, DC1394_FEATURE_GAMMA, 1);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Could not set gamma value");
}
err = dc1394_feature_set_power(dcam, DC1394_FEATURE_GAMMA, DC1394_OFF);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to disable gamma!");
return false;
}
/* Turn off white balance */
err = dc1394_feature_set_power(dcam, DC1394_FEATURE_WHITE_BALANCE, DC1394_OFF);
if (err != DC1394_SUCCESS) {
IDMessage(getDeviceName(), "Unable to disable white balance!");
return false;
}
err=dc1394_capture_setup(dcam,10, DC1394_CAPTURE_FLAGS_DEFAULT);
return true;
}
bool Camera::open(int deviceIdx) {
if (numCams < 1) {
std::cerr << "Camera not found or could not be opened." << std::endl;
return false;
}
camera = dc1394_camera_new(camDict, camList->ids[deviceIdx].guid);
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %.", camList->ids[deviceIdx].guid);
return false;
}
/* reset camera to initial state with default values */
resetCameraRegister();
/* prepare camera for ringlight leds */
configureOutputPins();
configureClockDelay();
configureClockDuration();
configureResetDelay();
configureResetDuration();
/* set video mode */
error = dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_640x480_MONO8);
if (error != DC1394_SUCCESS) {
std::cout << "Could not set video mode" << std::endl;
cleanup(camera);
return false;
}
/* camera parameter calibrated with FlyCapture2 */
/* brightness */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 0);
/* exposure */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_value(camera, DC1394_FEATURE_EXPOSURE, 149);
/* gamma */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAMMA, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_value(camera, DC1394_FEATURE_GAMMA, 1024);
/* shutter */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_value(camera, DC1394_FEATURE_SHUTTER, 61);
/* gain */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 740);
/* frame rate */
error = dc1394_feature_set_mode(camera, DC1394_FEATURE_FRAME_RATE, DC1394_FEATURE_MODE_MANUAL);
error = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_FRAME_RATE, FRAME_RATE);
/* setup capture */
error = dc1394_capture_setup(camera, numDMABuffers, DC1394_CAPTURE_FLAGS_DEFAULT);
if (error != DC1394_SUCCESS) {
std::cerr << "Could not setup camera-\nmake sure that the video mode and framerate are\nsupported by your camera" << std::endl;
cleanup(camera);
return false;
}
/* starting camera sending data */
error = dc1394_video_set_transmission(camera, DC1394_ON);
if (error != DC1394_SUCCESS) {
std::cerr << "Could not start camera iso transmission" << std::endl;
cleanup(camera);
return false;
}
/* capture image with no LEDs to subtract ambient light */
captureAmbientImage();
/* set average image intensity used by ps process for adjustment */
avgImgIntensity = cv::mean(ambientImage)[0];
return true;
}
CameraIIDC::CameraIIDC(unsigned int camNum, CameraTriggerMode triggerMode) : Camera(triggerMode) {
context = dc1394_new();
dc1394camera_list_t *camera_list;
dc1394error_t err;
err = dc1394_camera_enumerate(context, &camera_list);
if(camNum+1 > camera_list->num){
cerr << "libdc1394: Selected camera is not available!";
return;
}
cam = NULL;
cam = dc1394_camera_new(context, camera_list->ids[camNum].guid);
if(!cam){
cerr << "libdc1394: Could not open camera!";
return;
}
dc1394_camera_free_list(camera_list);
// // Get video modes
// dc1394video_modes_t video_modes;
// err=dc1394_video_get_supported_modes(cam, &video_modes);
// DC1394_WRN(err,"Can't get video modes");
// // Select highest res mode
// int i;
// dc1394color_coding_t coding;
// for (i=video_modes.num-1;i>=0;i--) {
// if (!dc1394_is_video_mode_scalable(video_modes.modes[i])) {
// dc1394_get_color_coding_from_video_mode(cam, video_modes.modes[i], &coding);
// DC1394_WRN(err,"libdc1394: Could not get color coding");
// if (coding==DC1394_COLOR_CODING_MONO8) {
// video_mode=video_modes.modes[i];
// break;
// }
// }
// }
// if (i < 0) {
// cerr << "libdc1394: Could not get a valid gray scale mode!";
// return;
// }
// Select format 7 mode 0
video_mode = DC1394_VIDEO_MODE_FORMAT7_0;
// Set bit depth
err = dc1394_format7_set_color_coding(cam, video_mode, DC1394_COLOR_CODING_MONO8);
if (err!=DC1394_SUCCESS)
cerr << "libdc1394: Could not set video mode or color coding!";
// // Set video mode
// err=dc1394_video_set_mode(cam, video_mode);
// if (err!=DC1394_SUCCESS)
// cerr << "libdc1394: Could not set video mode!";
// Setup capture
err=dc1394_video_set_operation_mode(cam, DC1394_OPERATION_MODE_1394B);
if (err!=DC1394_SUCCESS)
cerr << "libdc1394: Could not set operation mode!";
err=dc1394_video_set_iso_speed(cam, DC1394_ISO_SPEED_800);
if (err!=DC1394_SUCCESS)
cerr << "libdc1394: Could not set iso speed!";
// Size of ringbuffer (Note: on OS X 10.9, size must be greater than 1)
#ifdef __APPLE__
unsigned int bufferSize = 2;
#else
unsigned int bufferSize = 1;
#endif
err=dc1394_capture_setup(cam, bufferSize, DC1394_CAPTURE_FLAGS_DEFAULT);
if (err!=DC1394_SUCCESS)
cerr << "libdc1394: Could not set up camera!";
// Disable auto exposure mode
dc1394_feature_set_power(cam, DC1394_FEATURE_EXPOSURE, DC1394_OFF);
// Disable gamma mode
dc1394_feature_set_power(cam, DC1394_FEATURE_GAMMA, DC1394_OFF);
// Disable sharpness mode
dc1394_feature_set_power(cam, DC1394_FEATURE_SHARPNESS, DC1394_OFF);
// Disable frame-rate mode
dc1394_feature_set_power(cam, DC1394_FEATURE_FRAME_RATE, DC1394_OFF);
// Set manual settings
dc1394_feature_set_mode(cam, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_mode(cam, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
// Set reasonable default settings
CameraSettings settings;
//settings.shutter = 8.333;
settings.shutter = 16.66;
settings.gain = 0.0;
this->setCameraSettings(settings);
// Print camera features and settings
dc1394featureset_t features;
err=dc1394_feature_get_all(cam, &features);
DC1394_WRN(err, "libdc1394: Could not get feature set.");
dc1394_feature_print_all(&features, stdout);
fflush(stdout);
return;
}
void ofxLibdc::setFeature(dc1394feature_t feature, unsigned int value) {
dc1394_feature_set_power(camera, feature, DC1394_ON);
dc1394_feature_set_mode(camera, feature, DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_value(camera, feature, value);
}
static int s_set_parameters(capture_t *cap, const int index, camera_setting_t *s)
{
int ret = CAPTURE_SUCCESS;
dc1394camera_t *cam = cap->cameras[index];
dc1394error_t err;
/* set operation mode to 1394b, if possible */
if (cam->bmode_capable != 0 && cap->prefer_bmode) {
err = dc1394_video_set_operation_mode(cam, DC1394_OPERATION_MODE_1394B);
DC1394_WRN(err, "could not set 1394b mode.");
if (err == DC1394_SUCCESS) {
err = dc1394_video_set_iso_speed(cam, DC1394_ISO_SPEED_800);
DC1394_WRN(err, "could not set iso mode to S800.");
if (err != DC1394_SUCCESS) {
err = dc1394_video_set_iso_speed(cam, DC1394_ISO_SPEED_400);
DC1394_WRN(err, "could not set iso mode to S400.");
}
}
}
else {
err = dc1394_video_set_operation_mode(cam, DC1394_OPERATION_MODE_LEGACY);
DC1394_WRN(err, "could not set 1394-legacy mode.");
err = dc1394_video_set_iso_speed(cam, DC1394_ISO_SPEED_400);
DC1394_WRN(err, "could not set iso mode to S400.");
}
/* mode */
s->mode = s_get_appropriate_mode(cam, ((s->mode >= 0) ? s->mode : DC1394_VIDEO_MODE_640x480_MONO8));
if (dc1394_video_set_mode(cam, s->mode) != DC1394_SUCCESS) {
ret = CAPTURE_ERROR;
}
dc1394_video_get_mode(cam, &s->mode);
/* frame rate */
s->framerate = s_get_appropriate_framerate(cam, s->mode, ((s->framerate >= 0) ? s->framerate : DC1394_FRAMERATE_30));
if (dc1394_video_set_framerate(cam, s->framerate) != DC1394_SUCCESS) {
ret = CAPTURE_ERROR;
}
/*
features
*/
SET_FEATURE(DC1394_FEATURE_BRIGHTNESS, s->brightness);
SET_FEATURE(DC1394_FEATURE_EXPOSURE, s->exposure);
SET_FEATURE(DC1394_FEATURE_SHARPNESS, s->sharpness);
SET_FEATURE(DC1394_FEATURE_HUE, s->hue);
SET_FEATURE(DC1394_FEATURE_SATURATION, s->saturation);
SET_FEATURE(DC1394_FEATURE_GAMMA, s->gamma);
SET_FEATURE(DC1394_FEATURE_SHUTTER, s->shutter);
SET_FEATURE(DC1394_FEATURE_GAIN, s->gain);
SET_FEATURE(DC1394_FEATURE_IRIS, s->iris);
SET_FEATURE(DC1394_FEATURE_FOCUS, s->focus);
//SET_FEATURE(DC1394_FEATURE_TEMPERATURE, s->temperature); is not supported by dc1394_feature_set_value()
SET_FEATURE(DC1394_FEATURE_ZOOM, s->zoom);
SET_FEATURE(DC1394_FEATURE_PAN, s->pan);
SET_FEATURE(DC1394_FEATURE_TILT, s->tilt);
/* white blance */
if (s->white_balance[0] >= 0 && s->white_balance[1] >= 0) {
dc1394_feature_set_mode(cam, DC1394_FEATURE_WHITE_BALANCE, DC1394_FEATURE_MODE_MANUAL);
if (dc1394_feature_whitebalance_set_value(cam, s->white_balance[0], s->white_balance[1]) != DC1394_SUCCESS) {
ret = CAPTURE_ERROR;
}
}
else {
if (dc1394_feature_set_mode(cam, DC1394_FEATURE_WHITE_BALANCE, DC1394_FEATURE_MODE_AUTO) != DC1394_SUCCESS) {
ret = CAPTURE_ERROR;
}
}
return ret;
}
int main(int argc, char *argv[]) {
fitsfile *fptr;
long fpixel=1, nelements, naxes[2];
dc1394camera_t *camera;
int grab_n_frames;
struct timeval start_time, end_time;
int i, j, status;
unsigned int max_height, max_width;
uint64_t total_bytes = 0;
unsigned int width, height;
dc1394video_frame_t *frame=NULL;
dc1394_t * d;
dc1394camera_list_t * list;
dc1394error_t err;
char *filename;
unsigned char *buffer;
float *average;
grab_n_frames = atoi(argv[1]);
filename = argv[2];
status = 0;
width = 320;
height = 240;
naxes[0] = width;
naxes[1] = height;
nelements = naxes[0]*naxes[1];
stderr = freopen("grab_cube.log", "w", stderr);
d = dc1394_new();
if (!d)
return 1;
err = dc1394_camera_enumerate(d, &list);
DC1394_ERR_RTN(err, "Failed to enumerate cameras.");
if (list->num == 0) {
dc1394_log_error("No cameras found.");
return 1;
}
camera = dc1394_camera_new (d, list->ids[0].guid);
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %"PRIx64,
list->ids[0].guid);
return 1;
}
dc1394_camera_free_list(list);
printf("Using camera with GUID %"PRIx64"\n", camera->guid);
/*-----------------------------------------------------------------------
* setup capture for format 7
*-----------------------------------------------------------------------*/
// err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
// DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot operate at 1394B");
// libdc1394 doesn't work well with firewire800 yet so set to legacy 400 mode
dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
// configure camera for format7
err = dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot choose format7_0");
err = dc1394_format7_get_max_image_size (camera, DC1394_VIDEO_MODE_FORMAT7_1,
&max_width, &max_height);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get max image size for format7_0");
err = dc1394_format7_set_roi (camera,
DC1394_VIDEO_MODE_FORMAT7_1,
DC1394_COLOR_CODING_MONO8, // not sure why RAW8/16 don't work
DC1394_USE_MAX_AVAIL,
0, 0, // left, top
width, height); // width, height
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set roi");
// set the frame rate to absolute value in frames/sec
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_FRAME_RATE, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_FRAME_RATE, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_FRAME_RATE, 100.0);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate");
// set the shutter speed to absolute value in seconds
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, 1.0e-2);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter");
// set gain manually. use relative value here in range 48 to 730.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 200);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain");
// set brightness manually. use relative value in range 0 to 1023.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 50);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness");
err = dc1394_format7_get_total_bytes (camera, DC1394_VIDEO_MODE_FORMAT7_1, &total_bytes);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get total bytes");
// err = dc1394_feature_set_value (camera, DC1394_FEATURE_GAIN, 24);
//DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error setting gain");
err = dc1394_capture_setup(camera, 16, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error capturing");
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
err = dc1394_video_set_transmission(camera, DC1394_ON);
if (err != DC1394_SUCCESS) {
dc1394_log_error("unable to start camera iso transmission");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
/* allocate the buffers */
if (!(buffer = malloc(nelements*sizeof(char)))) {
printf("Couldn't Allocate Image Buffer\n");
exit(-1);
}
if (!(average = calloc(nelements, sizeof(float)))) {
printf("Couldn't Allocate Average Image Buffer\n");
exit(-1);
}
// set up FITS image and capture
fits_create_file(&fptr, filename, &status);
dc1394_get_image_size_from_video_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1, &width, &height);
fits_create_img(fptr, FLOAT_IMG, 2, naxes, &status);
/*-----------------------------------------------------------------------
* capture frames and measure the time for this operation
*-----------------------------------------------------------------------*/
gettimeofday(&start_time, NULL);
printf("Start capture:\n");
for (i=0; i<grab_n_frames; ++i) {
/*-----------------------------------------------------------------------
* capture one frame
*-----------------------------------------------------------------------*/
err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
if (err != DC1394_SUCCESS) {
dc1394_log_error("unable to capture");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
memcpy(buffer, frame->image, nelements*sizeof(char));
// release buffer
dc1394_capture_enqueue(camera,frame);
for (j=0; j<nelements; j++) {
average[j] += (1.0/grab_n_frames)*(buffer[j]);
}
}
gettimeofday(&end_time, NULL);
printf("End capture.\n");
/*-----------------------------------------------------------------------
* stop data transmission
*-----------------------------------------------------------------------*/
err = dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_RTN(err,"couldn't stop the camera?");
/*-----------------------------------------------------------------------
* save FITS image to disk
*-----------------------------------------------------------------------*/
fits_write_img(fptr, TFLOAT, fpixel, naxes[0]*naxes[1], average, &status);
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
free(buffer);
free(average);
printf("wrote: %s\n", filename);
printf("Readout is %d bits/pixel.\n", frame->data_depth);
/*-----------------------------------------------------------------------
* close camera, cleanup
*-----------------------------------------------------------------------*/
dc1394_capture_stop(camera);
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_camera_free(camera);
dc1394_free(d);
return 0;
}
int main(int argc, char *argv[])
{
fitsfile *fptr;
long fpixel=1, nelements, naxes[3];
dc1394camera_t *camera;
int grab_n_frames;
struct timeval start_time, end_time;
time_t start_sec, end_sec;
suseconds_t start_usec, end_usec;
float elapsed_time, fps;
int i, status;
unsigned int min_bytes, max_bytes, max_height, max_width;
unsigned int actual_bytes;
uint64_t total_bytes = 0;
unsigned int width, height;
dc1394video_frame_t *frame=NULL;
dc1394_t * d;
dc1394camera_list_t * list;
dc1394error_t err;
char *filename;
grab_n_frames = atoi(argv[1]);
filename = argv[2];
width = 320;
height = 240;
naxes[0] = width;
naxes[1] = height;
naxes[2] = grab_n_frames;
nelements = naxes[0]*naxes[1]*naxes[2];
stderr = freopen("grab_cube.log", "w", stderr);
d = dc1394_new ();
if (!d)
return 1;
err=dc1394_camera_enumerate (d, &list);
DC1394_ERR_RTN(err,"Failed to enumerate cameras");
if (list->num == 0) {
dc1394_log_error("No cameras found");
return 1;
}
camera = dc1394_camera_new (d, list->ids[0].guid);
if (!camera) {
dc1394_log_error("Failed to initialize camera with guid %"PRIx64,
list->ids[0].guid);
return 1;
}
dc1394_camera_free_list (list);
printf("Using camera with GUID %"PRIx64"\n", camera->guid);
/*-----------------------------------------------------------------------
* setup capture for format 7
*-----------------------------------------------------------------------*/
// err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
// DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot operate at 1394B");
// libdc1394 doesn't work well with firewire800 yet so set to legacy 400 mode
dc1394_video_set_iso_speed(camera, DC1394_ISO_SPEED_400);
// configure camera for format7
err = dc1394_video_set_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot choose format7_0");
printf ("I: video mode is format7_0\n");
err = dc1394_format7_get_max_image_size (camera, DC1394_VIDEO_MODE_FORMAT7_1,
&max_width, &max_height);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get max image size for format7_0");
printf ("I: max image size is: height = %d, width = %d\n", max_height, max_width);
printf ("I: current image size is: height = %d, width = %d\n", height, width);
err = dc1394_format7_set_roi (camera,
DC1394_VIDEO_MODE_FORMAT7_1,
DC1394_COLOR_CODING_MONO16, // not sure why RAW8/16 don't work
DC1394_USE_MAX_AVAIL,
0, 0, // left, top
width, height); // width, height
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set roi");
printf ("I: roi is (0, 0) - (%d, %d)\n", width, height);
// set the frame rate to absolute value in frames/sec
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_FRAME_RATE, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_FRAME_RATE, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_FRAME_RATE, 330.0);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set framerate");
printf("I: framerate is %f fps\n", 330.0);
// set the shutter speed to absolute value in seconds
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to manual");
err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_TRUE);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter to absolute mode");
err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, 3.0e-3);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set shutter");
printf("I: exptime is %f s\n", 3.0e-3);
// set gain manually. use relative value here in range 48 to 730.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_GAIN, 400);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set gain");
printf ("I: gain is %d\n", 400);
// set brightness manually. use relative value in range 0 to 1023.
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness to manual");
err = dc1394_feature_set_value(camera, DC1394_FEATURE_BRIGHTNESS, 100);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot set brightness");
printf ("I: brightness is %d\n", 100);
err = dc1394_format7_get_total_bytes (camera, DC1394_VIDEO_MODE_FORMAT7_1, &total_bytes);
DC1394_ERR_CLN_RTN(err,dc1394_camera_free (camera),"cannot get total bytes");
printf ("I: total bytes is %"PRIu64" before SFF enabled\n", total_bytes);
err=dc1394_capture_setup(camera, 16, DC1394_CAPTURE_FLAGS_DEFAULT);
DC1394_ERR_CLN_RTN(err, dc1394_camera_free(camera), "Error capturing");
/*-----------------------------------------------------------------------
* print allowed and used packet size
*-----------------------------------------------------------------------*/
err=dc1394_format7_get_packet_parameters(camera, DC1394_VIDEO_MODE_FORMAT7_1, &min_bytes, &max_bytes);
DC1394_ERR_RTN(err,"Packet para inq error");
printf( "camera reports allowed packet size from %d - %d bytes\n", min_bytes, max_bytes);
err=dc1394_format7_get_packet_size(camera, DC1394_VIDEO_MODE_FORMAT7_1, &actual_bytes);
DC1394_ERR_RTN(err,"dc1394_format7_get_packet_size error");
printf( "camera reports actual packet size = %d bytes\n", actual_bytes);
err=dc1394_format7_get_total_bytes(camera, DC1394_VIDEO_MODE_FORMAT7_1, &total_bytes);
DC1394_ERR_RTN(err,"dc1394_query_format7_total_bytes error");
printf( "camera reports total bytes per frame = %"PRId64" bytes\n",
total_bytes);
/*-----------------------------------------------------------------------
* have the camera start sending us data
*-----------------------------------------------------------------------*/
err=dc1394_video_set_transmission(camera,DC1394_ON);
if (err!=DC1394_SUCCESS) {
dc1394_log_error("unable to start camera iso transmission");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
// set up FITS image and capture
fits_create_file(&fptr, filename, &status);
dc1394_get_image_size_from_video_mode(camera, DC1394_VIDEO_MODE_FORMAT7_1, &width, &height);
fits_create_img(fptr, USHORT_IMG, 3, naxes, &status);
/*-----------------------------------------------------------------------
* capture frames and measure the time for this operation
*-----------------------------------------------------------------------*/
gettimeofday(&start_time, NULL);
printf("Start capture:\n");
for( i = 0; i < grab_n_frames; ++i) {
/*-----------------------------------------------------------------------
* capture one frame
*-----------------------------------------------------------------------*/
err=dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_WAIT, &frame);
if (err!=DC1394_SUCCESS) {
dc1394_log_error("unable to capture");
dc1394_capture_stop(camera);
dc1394_camera_free(camera);
exit(1);
}
// attempt to preallocate image array and write to memory before dumping to disk.
// turns out to be slow due to large size of images. cfitsio buffering is far
// more efficient.
//memcpy(im_buffer+2*i*naxes[0]*naxes[1],
//frame->image-1,
//naxes[0]*naxes[1]*sizeof(short));
// just writing each frame to the FITS file goes pretty fast
fits_write_img(fptr,
TUSHORT,
fpixel+i*naxes[0]*naxes[1],
naxes[0]*naxes[1],
frame->image-1,
&status);
// release buffer
dc1394_capture_enqueue(camera,frame);
}
gettimeofday(&end_time, NULL);
printf("End capture.\n");
/*-----------------------------------------------------------------------
* stop data transmission
*-----------------------------------------------------------------------*/
start_sec = start_time.tv_sec;
start_usec = start_time.tv_usec;
end_sec = end_time.tv_sec;
end_usec = end_time.tv_usec;
elapsed_time = (float)((end_sec + 1.0e-6*end_usec) - (start_sec + 1.0e-6*start_usec));
fps = grab_n_frames/elapsed_time;
printf("Elapsed time = %g seconds.\n", elapsed_time);
printf("Framerate = %g fps.\n", fps);
err=dc1394_video_set_transmission(camera,DC1394_OFF);
DC1394_ERR_RTN(err,"couldn't stop the camera?");
/*-----------------------------------------------------------------------
* save FITS image to disk
*-----------------------------------------------------------------------*/
//fits_write_img(fptr, TUSHORT, fpixel, naxes[0]*naxes[1]*naxes[2], im_buffer, &status);
fits_close_file(fptr, &status);
fits_report_error(stderr, status);
//free(im_buffer);
printf("wrote: %s\n", filename);
printf("Image is %d bits/pixel.\n", frame->data_depth);
/*-----------------------------------------------------------------------
* close camera, cleanup
*-----------------------------------------------------------------------*/
dc1394_capture_stop(camera);
dc1394_video_set_transmission(camera, DC1394_OFF);
dc1394_camera_free(camera);
dc1394_free (d);
return 0;
}
int main(int argc, char *argv[])
{
// parse configuration file
// get input arguments
OpenCvStereoConfig stereo_config;
string config_file = "";
ConciseArgs parser(argc, argv);
parser.add(config_file, "c", "config", "Configuration file containing camera GUIDs, etc.", true);
parser.add(left_camera_mode, "l", "left-camera", "Calibrate just the left camera.");
parser.add(right_camera_mode, "r", "right-camera", "Calibrate just the right camera.");
parser.add(force_brightness, "b", "brightness", "set brightness to this level");
parser.add(force_exposure, "e", "exposure", "set exposure to this level");
parser.parse();
// parse the config file
if (ParseConfigFile(config_file, &stereo_config) != true)
{
fprintf(stderr, "Failed to parse configuration file, quitting.\n");
return -1;
}
if (left_camera_mode || right_camera_mode)
{
stereo_mode = false;
}
uint64 guid = stereo_config.guidLeft;
uint64 guid2 = stereo_config.guidRight;
dc1394_t *d;
dc1394camera_t *camera;
dc1394error_t err;
Mat frame_array_left[MAX_FRAMES];
Mat frame_array_right[MAX_FRAMES];
int numFrames = 0;
// ----- cam 2 -----
dc1394_t *d2;
dc1394camera_t *camera2;
dc1394error_t err2;
d = dc1394_new ();
if (!d)
g_critical("Could not create dc1394 context");
d2 = dc1394_new ();
if (!d2)
g_critical("Could not create dc1394 context for camera 2");
camera = dc1394_camera_new (d, guid);
if (!camera)
g_critical("Could not create dc1394 camera");
camera2 = dc1394_camera_new (d2, guid2);
if (!camera2)
g_critical("Could not create dc1394 camera for camera 2");
// setup
err = setup_gray_capture(camera, DC1394_VIDEO_MODE_FORMAT7_1);
DC1394_ERR_CLN_RTN(err, cleanup_and_exit(camera), "Could not setup camera");
err2 = setup_gray_capture(camera2, DC1394_VIDEO_MODE_FORMAT7_1);
DC1394_ERR_CLN_RTN(err2, cleanup_and_exit(camera2), "Could not setup camera number 2");
// enable auto-exposure
// turn on the auto exposure feature
err = dc1394_feature_set_power(camera, DC1394_FEATURE_EXPOSURE, DC1394_ON);
DC1394_ERR_RTN(err,"Could not turn on the exposure feature");
err = dc1394_feature_set_mode(camera, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_ONE_PUSH_AUTO);
DC1394_ERR_RTN(err,"Could not turn on Auto-exposure");
// enable auto-exposure
// turn on the auto exposure feature
err = dc1394_feature_set_power(camera2, DC1394_FEATURE_EXPOSURE, DC1394_ON);
DC1394_ERR_RTN(err,"Could not turn on the exposure feature for cam2");
err = dc1394_feature_set_mode(camera2, DC1394_FEATURE_EXPOSURE, DC1394_FEATURE_MODE_ONE_PUSH_AUTO);
DC1394_ERR_RTN(err,"Could not turn on Auto-exposure for cam2");
// enable camera
err = dc1394_video_set_transmission(camera, DC1394_ON);
DC1394_ERR_CLN_RTN(err, cleanup_and_exit(camera), "Could not start camera iso transmission");
err2 = dc1394_video_set_transmission(camera2, DC1394_ON);
DC1394_ERR_CLN_RTN(err2, cleanup_and_exit(camera2), "Could not start camera iso transmission for camera number 2");
if (left_camera_mode || stereo_mode)
{
InitBrightnessSettings(camera, camera2);
MatchBrightnessSettings(camera, camera2, true, force_brightness, force_exposure);
} else {
// use the right camera as the master for brightness
// since we're calibrating that one
InitBrightnessSettings(camera2, camera);
MatchBrightnessSettings(camera2, camera, true);
}
// make opencv windows
if (left_camera_mode || stereo_mode)
{
namedWindow("Input Left", CV_WINDOW_AUTOSIZE);
moveWindow("Input Left", 100, 100);
}
if (right_camera_mode || stereo_mode)
{
namedWindow("Input Right", CV_WINDOW_AUTOSIZE);
moveWindow("Input Right", 478, 100);
}
CvSize size;
Mat cornersL, cornersR;
int i;
while (numFrames < MAX_FRAMES) {
Mat chessL, chessR;
// each loop dump a bunch of frames to clear the buffer
MatchBrightnessSettings(camera, camera2, true, force_brightness, force_exposure);
for (i=0;i<10;i++)
{
if (left_camera_mode || stereo_mode)
{
chessL = GetFrameFormat7(camera);
}
if (right_camera_mode || stereo_mode)
{
chessR = GetFrameFormat7(camera2);
}
}
// copy the images for drawing/display
size = chessL.size();
Mat chessLc;
chessLc.create(size, CV_32FC3);
Mat chessRc;
chessRc.create(size, CV_32FC3);
// attempt checkerboard matching
bool foundPattern = true; // set to true so we can do an OR
// later if we're only using one
// camera
if (left_camera_mode || stereo_mode)
{
foundPattern = findChessboardCorners(chessL, Size(CHESS_X, CHESS_Y), cornersL);
}
if (right_camera_mode || stereo_mode)
{
foundPattern = foundPattern & findChessboardCorners(chessR, Size(CHESS_X, CHESS_Y), cornersR);
}
if (left_camera_mode || stereo_mode)
{
cvtColor( chessL, chessLc, CV_GRAY2BGR );
drawChessboardCorners(chessLc, Size(CHESS_X, CHESS_Y), cornersL, foundPattern);
imshow("Input Left", chessLc);
}
if (right_camera_mode || stereo_mode)
{
cvtColor(chessR, chessRc, CV_GRAY2BGR);
drawChessboardCorners(chessRc, Size(CHESS_X, CHESS_Y), cornersR, foundPattern);
imshow("Input Right", chessRc);
}
// key codes:
// page up: 654365
// page down: 65366
// b: 98
char key = waitKey();
//printf("%d\n", (int)key);
if (key == 98)
{
break;
} else if (key == 86){
if (foundPattern)
{
// this was a good one -- save it
frame_array_left[numFrames] = chessL;
frame_array_right[numFrames] = chessR;
// give the user some guidence on the number
// of frames they should be using
if (stereo_mode)
{
printf("Saved frame %d / about 10\n", numFrames);
} else {
printf("Saved frame %d / about 20-30\n", numFrames);
}
numFrames ++;
} else {
printf("Not saving frame since did not find a checkboard.\n");
}
} else if (key == 'W') {
force_brightness +=20;
cout << "Brightness: " << force_brightness << "\n";
} else if (key == 'w') {
force_brightness -=20;
cout << "Brightness: " << force_brightness << "\n";
} else if (key == 'E') {
force_exposure +=20;
cout << "Exposure: " << force_exposure << "\n";
} else if (key == 'e') {
force_exposure -=20;
cout << "Exposure: " << force_exposure << "\n";
}
}
printf("\n\n");
// clear out the calibration directory
printf("Deleting old images...\nrm calibrationImages/*.ppm\n");
int retval = system("rm calibrationImages/*.ppm");
if (retval != 0) {
printf("Warning: Deleting images may have failed.\n");
}
printf("done.\n");
char filename[1000];
for (i=0;i<numFrames;i++)
{
if (left_camera_mode || stereo_mode)
{
sprintf(filename, "calibrationImages/cam1-%05d.ppm", i+1);
imwrite(filename, frame_array_left[i]);
}
if (right_camera_mode || stereo_mode)
{
sprintf(filename, "calibrationImages/cam2-%05d.ppm", i+1);
imwrite(filename, frame_array_right[i]);
}
printf("Writing frame %d\n", i);
}
printf("\n\n");
destroyWindow("Input Left");
destroyWindow("Input Right");
// stop data transmission
err = dc1394_video_set_transmission(camera, DC1394_OFF);
DC1394_ERR_CLN_RTN(err,cleanup_and_exit(camera),"Could not stop the camera");
err2 = dc1394_video_set_transmission(camera2, DC1394_OFF);
DC1394_ERR_CLN_RTN(err2,cleanup_and_exit(camera2),"Could not stop the camera 2");
// close camera
cleanup_and_exit(camera);
cleanup_and_exit(camera2);
dc1394_free (d);
dc1394_free (d2);
return 0;
}
