double CvCaptureCAM_DC1394_v2_CPP::getProperty(int propId)
{
switch (propId)
{
case CV_CAP_PROP_FRAME_WIDTH:
return frameWidth ? frameWidth : frameHeight*4 / 3;
case CV_CAP_PROP_FRAME_HEIGHT:
return frameHeight ? frameHeight : frameWidth*3 / 4;
case CV_CAP_PROP_FPS:
return fps;
case CV_CAP_PROP_RECTIFICATION:
return rectify ? 1 : 0;
case CV_CAP_PROP_WHITE_BALANCE_BLUE_U:
if (dc1394_feature_whitebalance_get_value(dcCam,
&feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].BU_value,
&feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].RV_value) == DC1394_SUCCESS)
return feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].BU_value;
break;
case CV_CAP_PROP_WHITE_BALANCE_RED_V:
if (dc1394_feature_whitebalance_get_value(dcCam,
&feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].BU_value,
&feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].RV_value) == DC1394_SUCCESS)
return feature_set.feature[DC1394_FEATURE_WHITE_BALANCE-DC1394_FEATURE_MIN].RV_value;
break;
case CV_CAP_PROP_GUID:
//the least 32 bits are enough to identify the camera
return (double) (guid & 0x00000000FFFFFFFF);
break;
case CV_CAP_PROP_MODE:
return (double) userMode;
break;
case CV_CAP_PROP_ISO_SPEED:
return (double) isoSpeed;
default:
if (propId<CV_CAP_PROP_MAX_DC1394 && dc1394properties[propId]!=-1
&& dcCam)
//&& feature_set.feature[dc1394properties[propId]-DC1394_FEATURE_MIN].on_off_capable)
if (dc1394_feature_get_value(dcCam,(dc1394feature_t)dc1394properties[propId],
&feature_set.feature[dc1394properties[propId]-DC1394_FEATURE_MIN].value) == DC1394_SUCCESS)
return feature_set.feature[dc1394properties[propId]-DC1394_FEATURE_MIN].value;
}
return -1; // the value of the feature can be 0, so returning 0 as an error is wrong
}
void FWCamera::getWhitebalance(int* pU, int* pV) const
{
#ifdef AVG_ENABLE_1394_2
dc1394error_t err = dc1394_feature_whitebalance_get_value(m_pCamera,
(uint32_t*)pU, (uint32_t*)pV);
if (err != DC1394_SUCCESS) {
AVG_LOG_WARNING("Camera: Unable to get whitebalance setting. Error was " << err);
}
#endif
}
/** Get feature values.
*
* @pre feature_set_ initialized for this camera
*
* @param finfo pointer to information for this feature
* @param value [out] pointer where parameter value stored
* @param value2 [out] optional pointer for second parameter value
* for white balance. Otherwise NULL.
*/
void Features::getValues(dc1394feature_info_t *finfo,
double *value, double *value2)
{
dc1394feature_t feature = finfo->id;
dc1394error_t rc;
if (!finfo->readout_capable)
{
ROS_INFO_STREAM("feature " << featureName(feature)
<< " value not available from device");
return;
}
if (feature == DC1394_FEATURE_WHITE_BALANCE)
{
// handle White Balance separately, it has two components
if (finfo->absolute_capable && finfo->abs_control)
{
// supports reading and setting float value
// @todo get absolute White Balance values
rc = DC1394_FUNCTION_NOT_SUPPORTED;
}
else
{
// get integer White Balance values
uint32_t bu_val;
uint32_t rv_val;
rc = dc1394_feature_whitebalance_get_value(camera_, &bu_val, &rv_val);
if (DC1394_SUCCESS == rc)
{
// convert to double
*value = bu_val;
*value2 = rv_val;
}
}
if (DC1394_SUCCESS == rc)
{
ROS_DEBUG_STREAM("feature " << featureName(feature)
<< " Blue/U: " << *value
<< " Red/V: " << *value2);
}
else
{
ROS_WARN_STREAM("failed to get values for feature "
<< featureName(feature));
}
}
else
{
// other features only have one component
if (finfo->absolute_capable && finfo->abs_control)
{
// supports reading and setting float value
float fval;
rc = dc1394_feature_get_absolute_value(camera_, feature, &fval);
if (DC1394_SUCCESS == rc)
{
*value = fval; // convert to double
}
}
else // no float representation
{
uint32_t ival;
rc = dc1394_feature_get_value(camera_, feature, &ival);
if (DC1394_SUCCESS == rc)
{
*value = ival; // convert to double
}
}
if (DC1394_SUCCESS == rc)
{
ROS_DEBUG_STREAM("feature " << featureName(feature)
<< " has value " << *value);
}
else
{
ROS_WARN_STREAM("failed to get value of feature "
<< featureName(feature));
}
}
}
int ar2VideoGetValue1394(AR2VideoParam1394T *vid, int paramName, int *value)
{
unsigned int ub, vr;
switch (paramName)
{
case AR_VIDEO_1394_BRIGHTNESS:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_BRIGHTNESS, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get brightness.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_EXPOSURE:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_EXPOSURE, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get exposure.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_WHITE_BALANCE_UB:
if (dc1394_feature_whitebalance_get_value(vid->camera, (uint32_t*)value, &vr) != DC1394_SUCCESS)
{
ARLOGe("unable to get white balance ub.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_WHITE_BALANCE_VR:
if (dc1394_feature_whitebalance_get_value(vid->camera, &ub, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get white balance vr.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_SHUTTER_SPEED:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_SHUTTER, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get shutter speed.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_GAIN:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_GAIN, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get gain.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_FOCUS:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_FOCUS, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get focus.\n");
return -1;
}
return 0;
case AR_VIDEO_1394_GAMMA:
if (dc1394_feature_get_value(vid->camera, DC1394_FEATURE_GAMMA, (uint32_t*)value) != DC1394_SUCCESS)
{
ARLOGe("unable to get gamma.\n");
return -1;
}
return 0;
}
return -1;
}
void FWCamera::getCameraControls(dc1394camera_t* pCamera, CameraInfo* camInfo)
{
dc1394featureset_t featureSet;
int err = dc1394_feature_get_all(pCamera, &featureSet);
if (err != DC1394_SUCCESS) {
AVG_ASSERT(false);
return;
}
for (int i = DC1394_FEATURE_MIN; i <= DC1394_FEATURE_MAX; i++) {
dc1394feature_info_t featureInfo = featureSet.feature[i - DC1394_FEATURE_MIN];
dc1394bool_t bool_t;
dc1394_feature_is_present(pCamera,featureInfo.id, &bool_t);
if (bool_t != DC1394_TRUE) {
continue;
}
uint32_t min = -1;
uint32_t max = -1;
uint32_t actValue = -1;
//TODO: 428 (TRIGGER) doesnt have min max
err = dc1394_feature_get_boundaries(pCamera, featureInfo.id, &min, &max);
if (err != DC1394_SUCCESS) {
continue;
}
switch(featureInfo.id) {
case DC1394_FEATURE_TEMPERATURE: {
uint32_t targetTemp = -1;
uint32_t currentTemp = -1;
err = dc1394_feature_temperature_get_value(pCamera,&targetTemp,¤tTemp);
if (err != DC1394_SUCCESS) {
continue;
}
actValue = currentTemp;
break;
}
//TODO: Think about a way to get this information into CameraInfo
case DC1394_FEATURE_WHITE_BALANCE: {
uint32_t ubValue = -1;
uint32_t vrValue = -1;
err = dc1394_feature_whitebalance_get_value(pCamera,&ubValue,&vrValue);
if (err != DC1394_SUCCESS) {
continue;
}
//actValue = ubValue; //vrValue;
//cout <<"UBlue Value: " << ubValue << " VRed Value: " << vrValue << endl;
break;
}
default: {
err = dc1394_feature_get_value(pCamera,featureInfo.id, &actValue);
if (err != DC1394_SUCCESS) {
continue;
}
break;
}
}
CameraFeature enumFeature = featureIDToEnum(featureInfo.id);
if (enumFeature == CAM_FEATURE_UNSUPPORTED) {
continue;
}
std::string controlName = cameraFeatureToString(enumFeature);
CameraControl control = CameraControl(controlName,
(int) min,
(int) max,
(int) actValue ); //TODO: isnt really a default value!?
camInfo->addControl(control);
}
}
void DC1394Camera::init(core::ConfigNode config, uint64_t guid)
{
LOGGER.infoStream() << guid << ": Initializing camera ";
m_guid = guid;
// Grab our camera
m_camera = dc1394_camera_new(s_libHandle, guid);
if (!m_camera) {
LOGGER.errorStream() <<
"Failed to initialize camera with guid: " << guid;
assert(m_camera && "Couldn't initialize camera");
}
// Determines settings and frame size
dc1394error_t err = DC1394_FAILURE;
dc1394video_mode_t videoMode = DC1394_VIDEO_MODE_640x480_RGB8;
dc1394framerate_t frameRate = DC1394_FRAMERATE_15;
// Check for the whitebalance feature
dc1394feature_info_t whiteBalance;
whiteBalance.id = DC1394_FEATURE_WHITE_BALANCE;
err = dc1394_feature_get(m_camera, &whiteBalance);
assert(DC1394_SUCCESS == err && "Could not get white balance feature info");
bool hasWhiteBalance = (whiteBalance.available == DC1394_TRUE);
uint32_t uValue, vValue;
if (hasWhiteBalance)
{
err = dc1394_feature_whitebalance_get_value(m_camera, &uValue, &vValue);
LOGGER.infoStream() << m_guid
<< ": Current U: " << uValue
<< " V: " << vValue;
}
// Actually set the values if the user wants to
if (config.exists("uValue") && config.exists("vValue"))
{
bool uAuto =
boost::to_lower_copy(config["uValue"].asString("auto")) == "auto";
bool vAuto =
boost::to_lower_copy(config["vValue"].asString("auto")) == "auto";
bool autoVal = uAuto && vAuto;
if ((uAuto || vAuto) && !autoVal)
{
assert(false && "Both Whitebalance values must either be auto or manual");
}
if (autoVal)
{
setWhiteBalance(0, 0, true);
}
else
{
// Read in config values
uint32_t u_b_value = static_cast<uint32_t>(config["uValue"].asInt());
uint32_t v_r_value = static_cast<uint32_t>(config["vValue"].asInt());
// Set values
setWhiteBalance(u_b_value, v_r_value);
}
}
else if (config.exists("uValue") || config.exists("vValue"))
{
assert(false && "Must set both the U and V values for white balance");
}
err = dc1394_feature_whitebalance_get_value(m_camera, &uValue, &vValue);
LOGGER.infoStream() << m_guid
<< ": Set U: " << uValue
<< " V: " << vValue;
if (config.exists("brightness"))
{
// Read in and set values
if (boost::to_lower_copy(config["brightness"].asString("auto")) == "auto")
{
setBrightness(0, true);
}
else
{
uint32_t value = static_cast<uint32_t>(config["brightness"].asInt());
setBrightness(value);
}
}
if (config.exists("exposure"))
{
// Read in and set values
if (boost::to_lower_copy(config["exposure"].asString("auto")) == "auto")
{
setExposure(0, true);
}
else
{
uint32_t value = static_cast<uint32_t>(config["exposure"].asInt());
setExposure(value);
}
}
// Grab image size
err = dc1394_get_image_size_from_video_mode(m_camera, videoMode,
&m_width, &m_height);
assert(DC1394_SUCCESS == err && "Could not get image size");
float fRate;
err = dc1394_framerate_as_float(frameRate, &fRate);
assert(DC1394_SUCCESS == err && "Could not get framerate as float");
m_fps = fRate;
// Setup the capture
err = dc1394_video_set_iso_speed(m_camera, DC1394_ISO_SPEED_400);
assert(DC1394_SUCCESS == err && "Could not set iso speed");
err = dc1394_video_set_mode(m_camera, videoMode);
assert(DC1394_SUCCESS == err && "Could not set video mode");
err = dc1394_video_set_framerate(m_camera, frameRate);
assert(DC1394_SUCCESS == err && "Could not set framerate");
// Start data transfer
err = dc1394_video_set_transmission(m_camera, DC1394_ON);
assert(DC1394_SUCCESS == err && "Could not start camera iso transmission");
err = dc1394_capture_setup(m_camera, DMA_BUFFER_SIZE,
DC1394_CAPTURE_FLAGS_DEFAULT);
assert(DC1394_SUCCESS == err && "Could not setup camera make sure"
" that the video mode and framerate are supported by your camera");
}
