//! Run
void PS3::Run() {
if ( !_bInitialized ) {
return;
}
int width, height;
//IplImage *pCapImage;
_cam = CLEyeCreateCamera( _camGUID, _camColorMode, _camResolution, _frameRate );
//Sleep( 300 );
if ( _cam == NULL ) {
printf( "\nPS3::Run()\tCould not create camera\n" );
return; //! Could not create camera
}
//printf( "\tPS3::Run()\t#1\n" );
CLEyeCameraGetFrameDimensions( _cam, width, height );
_pCapBuffer = new unsigned char[width * height * 4];
//printf( "PS3::Run() p=%p\n", _pCapBuffer );
//if ( _camColorMode == CLEYE_COLOR_PROCESSED || _camColorMode == CLEYE_COLOR_RAW ) {
// pCapImage = cvCreateImage( cvSize(width, height), IPL_DEPTH_8U, 4 );
//} else {
// pCapImage = cvCreateImage( cvSize(width, height), IPL_DEPTH_8U, 1 );
//}
//! Set some camera parameters
CLEyeSetCameraParameter( _cam, CLEYE_AUTO_GAIN, _bAutoGain );
CLEyeSetCameraParameter( _cam, CLEYE_GAIN, _gainValue );
CLEyeSetCameraParameter( _cam, CLEYE_AUTO_EXPOSURE, _bAutoExposure );
CLEyeSetCameraParameter( _cam, CLEYE_EXPOSURE, _exposureValue );
CLEyeSetCameraParameter( _cam, CLEYE_AUTO_WHITEBALANCE, _bAutoWhiteBalance );
CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_RED, _whiteBalanceRed );
CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_GREEN, _whiteBalanceGreen );
CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_BLUE, _whiteBalanceBlue );
CLEyeSetCameraParameter( _cam, CLEYE_HFLIP, _bHFlip );
CLEyeSetCameraParameter( _cam, CLEYE_VFLIP, _bVFlip );
//! Start capturing
if ( !CLEyeCameraStart( _cam ) ) {
std::cout << "Could not start camera!\n" << std::endl;
return;
}
//Sleep( 300 );
}
// ------------------------------------------------
// PRIVATE
// ------------------------------------------------
bool PS3::SetWhiteBalance( int color, int value ) {
if ( _bRunning && !GetAutoWhiteBalance() ) {
if ( _cam != NULL ) {
switch ( color ) {
case 0: // Red
if ( CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_RED, value ) ) {
_whiteBalanceRed = value;
return true;
}
break;
case 1: // Green
if ( CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_GREEN, value ) ) {
_whiteBalanceGreen = value;
return true;
}
break;
case 2: // Blue
if ( CLEyeSetCameraParameter( _cam, CLEYE_WHITEBALANCE_BLUE, value ) ) {
_whiteBalanceBlue = value;
return true;
}
break;
default:
break;
}
}
} else {
switch ( color ) {
case 0: // Red
_whiteBalanceRed = value;
break;
case 1: // Green
_whiteBalanceGreen = value;
break;
case 2: // Blue
_whiteBalanceBlue = value;
break;
}
return true;
}
return false;
}
bool setProperty(int property_id, double value)
{
int val;
if (!m_eye)
{
return false;
}
switch (property_id)
{
case CV_CAP_PROP_BRIGHTNESS:
// [-500, 500]
CLEyeSetCameraParameter(m_eye, CLEYE_LENSBRIGHTNESS, (int)value);
case CV_CAP_PROP_CONTRAST:
return false;
case CV_CAP_PROP_EXPOSURE:
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_EXPOSURE, value <= 0);
if (value > 0)
{
//[0, 255] -> [0, 511]
val = (int)(value * 2.0);
CLEyeSetCameraParameter(m_eye, CLEYE_EXPOSURE, val);
}
case CV_CAP_PROP_FPS:
return false; //TODO: Modifying FPS probably requires resetting the camera
case CV_CAP_PROP_FRAME_HEIGHT:
return false; //TODO: Modifying frame size probably requires resetting the camera
case CV_CAP_PROP_FRAME_WIDTH:
return false; //TODO: Modifying frame size probably requires resetting the camera
case CV_CAP_PROP_GAIN:
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_GAIN, value <= 0);
if (value > 0)
{
//[0, 255] -> [0, 79]
val = (int)ceil(value * 80.0 / 256.0);
CLEyeSetCameraParameter(m_eye, CLEYE_GAIN, val);
}
case CV_CAP_PROP_HUE:
return false;
case CV_CAP_PROP_SHARPNESS:
return false; // TODO: Using OpenCV interface, sharpness appears to work
}
return true;
}
bool PS3::DecrementParam( int param ) {
if ( !_cam ) {
return false;
}
int nowValue = CLEyeGetCameraParameter( _cam, (CLEyeCameraParameter)param );
printf( "CLEyeGetParameter %d\n", nowValue );
//! We decrease value by 10
CLEyeSetCameraParameter( _cam, (CLEyeCameraParameter)param, nowValue - 10);
return true;
}
bool open(int _index) {
close();
int cams = CLEyeGetCameraCount();
std::cout << "CLEyeGetCameraCount() found " << cams << " devices." << std::endl;
if (_index < cams)
{
std::cout << "Attempting to open camera " << _index << " of " << cams << "." << std::endl;
GUID guid = CLEyeGetCameraUUID(_index);
m_eye = CLEyeCreateCamera(guid, CLEYE_COLOR_PROCESSED, CLEYE_VGA, 75);
CLEyeCameraGetFrameDimensions(m_eye, m_width, m_height);
m_frame4ch = cvCreateImage(cvSize(m_width, m_height), IPL_DEPTH_8U, 4);
m_frame = cvCreateImage(cvSize(m_width, m_height), IPL_DEPTH_8U, 3);
CLEyeCameraStart(m_eye);
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_EXPOSURE, false);
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_GAIN, false);
m_index = _index;
}
return isOpened();
}
//--------------------------------------------------------------
void ofxCLEye::setAutoWhiteBalance(bool autoWhiteBalance){
if(!initialized){
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_AUTO_WHITEBALANCE, (int)autoWhiteBalance);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "AUTO WHITE BALANCE: " << (autoWhiteBalance ? "ON" : "OFF");
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setAutoWhiteBalance(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
bool PS3::SetExposure( int value ) {
if ( _bRunning && !GetAutoExposure() ) {
if ( _cam != NULL && CLEyeSetCameraParameter( _cam, CLEYE_EXPOSURE, value ) ) {
_exposureValue = value;
return true;
}
} else {
_exposureValue = value;
return true;
}
return false;
}
bool PS3::SetGainValue( int value ) {
if ( _bRunning && !GetAutoGain() ) { // Could not set the gain value when auto mode on
if ( _cam != NULL && CLEyeSetCameraParameter( _cam, CLEYE_GAIN, value ) ) {
_gainValue = value;
return true;
}
} else {
_gainValue = value;
return true;
}
return false;
}
//--------------------------------------------------------------
void ofxCLEye::setAutoExposure(bool autoExposure){
if(!initialized){
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_AUTO_EXPOSURE, (int)autoExposure);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "AUTO EXPOSURE: " << (autoExposure ? "ON" : "OFF");
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setAutoExposure():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setAutoGain(bool autoGain){
if(!initialized){
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_AUTO_GAIN, (int)autoGain);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "AUTO GAIN: " << (autoGain ? "ON" : "OFF");
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setAutoGain(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setHorizontalFlip(bool hFlip){
if(!initialized){
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_HFLIP, (int)hFlip);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "HORIZONTAL FLIP: " << (hFlip ? "ON" : "OFF");
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setHorizontalFlip(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
void camera_control_set_parameters(CameraControl* cc, int autoE, int autoG, int autoWB, int exposure, int gain, int wbRed, int wbGreen, int wbBlue, int contrast, int brightness)
{
#if defined(CAMERA_CONTROL_USE_CL_DRIVER)
if (autoE >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_AUTO_EXPOSURE, autoE > 0);
if (autoG >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_AUTO_GAIN, autoG > 0);
if (autoWB >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_AUTO_WHITEBALANCE, autoWB > 0);
if (exposure >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_EXPOSURE, round((511 * exposure) / 0xFFFF));
if (gain >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_GAIN, round((79 * gain) / 0xFFFF));
if (wbRed >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_WHITEBALANCE_RED, round((255 * wbRed) / 0xFFFF));
if (wbGreen >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_WHITEBALANCE_GREEN, round((255 * wbGreen) / 0xFFFF));
if (wbBlue >= 0)
CLEyeSetCameraParameter(cc->camera, CLEYE_WHITEBALANCE_BLUE, round((255 * wbBlue) / 0xFFFF));
#elif defined(CAMERA_CONTROL_USE_PS3EYE_DRIVER)
//autoE... setAutoExposure not defined in ps3eye.h
ps3eye_set_parameter(cc->eye, PS3EYE_AUTO_GAIN, autoG > 0);
ps3eye_set_parameter(cc->eye, PS3EYE_AUTO_WHITEBALANCE, autoWB > 0);
ps3eye_set_parameter(cc->eye, PS3EYE_EXPOSURE, (int)round((511 * exposure) / 0xFFFF));
ps3eye_set_parameter(cc->eye, PS3EYE_GAIN, (int)round((79 * gain) / 0xFFFF));
ps3eye_set_parameter(cc->eye, PS3EYE_BRIGHTNESS, (int)round((255 * brightness) / 0xFFFF));
//ps3eye_set_parameter(cc->eye, PS3EYE_REDBALANCE, round((255 * wbRed) / 0xFFFF));
//wbGreen... setGreenBalance not defined in ps3eye.h
//ps3eye_set_parameter(cc->eye, PS3EYE_BLUEBALANCE, round((255 * wbBlue) / 0xFFFF));
//ps3eye_set_parameter(cc->eye, PS3EYE_CONTRAST, contrast); // Transform unknown.
//ps3eye_set_parameter(cc->eye, PS3EYE_BRIGHTNESS, brightness); // Transform unknown.
/** The following parameters could be set but are not passed into this function:
* ps3eye_set_parameter(cc->eye, PS3EYE_SHARPNESS, ??);
* ps3eye_set_parameter(cc->eye, PS3EYE_HUE, ??);
* ps3eye_set_parameter(cc->eye, PS3EYE_HFLIP, ??);
* ps3eye_set_parameter(cc->eye, PS3EYE_VFLIP, ??);
**/
#else
int val;
HKEY hKey;
DWORD l = sizeof(DWORD);
char* PATH = CL_DRIVER_REG_PATH;
int err = RegOpenKeyEx(HKEY_CURRENT_USER, PATH, 0, KEY_ALL_ACCESS, &hKey);
if (err != ERROR_SUCCESS) {
printf("Error: %d Unable to open reg-key: [HKCU]\%s!", err, PATH);
return;
}
//--------------------------------------------------------------
void ofxCLEye::setVerticalFlip(bool vFlip){
if(!initialized){
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_VFLIP, (int)vFlip);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "VERTICAL FLIP: " << (vFlip ? "ON" : "OFF");
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setVerticalFlip(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
bool PS3::SetAutoWhiteBalance( bool autoBalance ) {
if ( _bRunning ) {
if ( _cam != NULL
&& CLEyeSetCameraParameter( _cam, CLEYE_AUTO_WHITEBALANCE, autoBalance ) ) {
_bAutoWhiteBalance = autoBalance;
return true;
}
} else {
_bAutoWhiteBalance = autoBalance;
return true;
}
return false;
}
bool PS3::SetAutoGain( bool autoGain ) {
if ( _bRunning ) {
if ( _cam != NULL
&& CLEyeSetCameraParameter( _cam, CLEYE_AUTO_GAIN, autoGain ) ) {
_bAutoGain = autoGain;
return true;
}
} else {
_bAutoGain = autoGain;
return true;
}
return false;
}
bool PS3::SetVFlip( bool flip ) {
if ( _bRunning ) {
if ( _cam != NULL
&& CLEyeSetCameraParameter( _cam, CLEYE_VFLIP, flip ) ) {
_bVFlip = flip;
return true;
}
} else {
_bVFlip = flip;
return true;
}
return false;
}
bool PS3::SetAutoExposure( bool autoExposure ) {
if ( _bRunning ) {
if ( _cam != NULL
&& CLEyeSetCameraParameter( _cam, CLEYE_AUTO_EXPOSURE, autoExposure ) ) {
_bAutoExposure = autoExposure;
return true;
}
} else {
_bAutoExposure = autoExposure;
return true;
}
return false;
}
//--------------------------------------------------------------
void ofxCLEye::setLensBrightness(int brightness){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensBrightness():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(brightness < -500 || brightness > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensBrightness():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_LENSBRIGHTNESS, brightness);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "LENS BRIGHTNESS: " << brightness;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensBrightness(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setLensCorrection3(int correction){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensCorrection3():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(correction < -500 || correction > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensCorrection3():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_LENSCORRECTION3, correction);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "LENS CORRECTION 3: " << correction;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setLensCorrection3(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setWhiteBalanceGreen(int green){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceGreen():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(green < 0 || green > 255){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceGreen():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_WHITEBALANCE_GREEN, green);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "WHITE BALANCE (GREEN): " << green;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceGreen():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setGain(int gain){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setGain():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(gain < 0 || gain > 79){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setGain():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_GAIN, gain);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "GAIN: " << gain;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setGain():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setVerticalKeystone(int vKeystone){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setVerticalKeystone():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(vKeystone < -500 || vKeystone > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setVerticalKeystone():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_VKEYSTONE, vKeystone);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "VERTICAL KEYSTONE: " << vKeystone;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setVerticalKeystone(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setHorizontalKeystone(int hKeystone){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setHorizontalKeystone():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(hKeystone < -500 || hKeystone > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setHorizontalKeystone():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_HKEYSTONE, hKeystone);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "HORIZONTAL KEYSTONE: " << hKeystone;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setHorizontalKeystone(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setWhiteBalanceBlue(int blue){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceBlue():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(blue < 0 || blue > 255){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceBlue():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_WHITEBALANCE_BLUE, blue);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "WHITE BALANCE (BLUE): " << blue;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceBlue():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setExposure(int exposure){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setExposure():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(exposure < 0 || exposure > 511){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setExposure():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_EXPOSURE, exposure);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "EXPOSURE: " << exposure;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setExposure():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setWhiteBalanceRed(int red){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceRed():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(red < 0 || red > 255){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceRed():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_WHITEBALANCE_RED, red);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "WHITE BALANCE (RED): " << red;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setWhiteBalanceRed():" << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setYOffset(int yOffset){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setYOffset():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(yOffset < -500 || yOffset > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setYOffset():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_YOFFSET, yOffset);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "Y OFFSET: " << yOffset;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setYOffset(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setZoom(int zoom){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setZoom():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(zoom < -500 || zoom > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setZoom():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_ZOOM, zoom);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "ZOOM: " << zoom;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setZoom(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
//--------------------------------------------------------------
void ofxCLEye::setRotation(int rotation){
if(!initialized){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setRotation():" << OFX_CLEYE_GRABBER_ERROR;
return;
}
if(rotation < -500 || rotation > 500){
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setRotation():" << OFX_CLEYE_INVALID_VALUE;
return;
}
bool success = CLEyeSetCameraParameter(cam, CLEYE_ROTATION, rotation);
if(success){
ofLogVerbose(OFX_CLEYE_MODULE_NAME) << "ROTATION: " << rotation;
}
else{
ofLogWarning(OFX_CLEYE_MODULE_NAME) << "setRotation(): " << OFX_CLEYE_SET_PROPERTY_ERROR;
}
}
void EyeCameraCapture::SetCameraParameter(CLEyeCameraParameter param, int value) {
if(!_cam) return;
printf("CLEyeGetCameraParameter %d\n", CLEyeGetCameraParameter(_cam, (CLEyeCameraParameter)param));
CLEyeSetCameraParameter(_cam, (CLEyeCameraParameter)param, value);
}