DragonflyDeviceDriver2.cpp

Go to the documentation of this file.

// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
 
/*
 * Copyright (C) 2007 RobotCub Consortium
 * Author: Alessandro Scalzo alessandro.scalzo@iit.it
 * CopyPolicy: Released under the terms of the GNU GPL v2.0.
 *
 */
 
#include "common/DragonflyDeviceDriver2.h"
 
#include <yarp/os/Stamp.h>
#include <yarp/dev/DeviceDriver.h>
#include <yarp/dev/FrameGrabberInterfaces.h>
#include <yarp/os/Log.h>
#include <yarp/os/LogStream.h>
 
using namespace yarp::os;
using namespace yarp::dev;
 
#include "FirewireCameraDC1394-DR2_2.h"
 
inline CFWCamera_DR2_2* RES(void *res) { return (CFWCamera_DR2_2*)res; }
 
bool DragonflyDeviceDriver2Rgb::getImage(yarp::sig::ImageOf<yarp::sig::PixelRgb>& image) 
{
    return RES(system_resources)->CaptureImage(image);
}
 
bool DragonflyDeviceDriver2Rgb::getImage(yarp::sig::ImageOf<yarp::sig::PixelMono>& image)
{
    return RES(system_resources)->CaptureImage(image);
}
 
int DragonflyDeviceDriver2Rgb::width () const
{
    return RES(system_resources)->width();
}
 
int DragonflyDeviceDriver2Rgb::height () const
{
    return RES(system_resources)->height();
}
 
bool DragonflyDeviceDriver2Raw::getImage(yarp::sig::ImageOf<yarp::sig::PixelMono>& image) 
{
    return RES(system_resources)->CaptureImage(image);
}
 
int DragonflyDeviceDriver2Raw::width () const
{
    return RES(system_resources)->width();
}
 
int DragonflyDeviceDriver2Raw::height () const
{
    return RES(system_resources)->height();
}
 
 
DragonflyDeviceDriver2::DragonflyDeviceDriver2(bool raw) :
    raw(raw), system_resources(NULL)
{
}
 
DragonflyDeviceDriver2::~DragonflyDeviceDriver2()
{
    if (system_resources)
    {
        delete (CFWCamera_DR2_2*)system_resources;
        system_resources=NULL;
    }
}
 
bool DragonflyDeviceDriver2::open(yarp::os::Searchable& config)
{
    if(config.check("pixelType"))
    {
        if(config.find(("pixelType")).asVocab32()==VOCAB_PIXEL_MONO)
            raw=true;
        else if((config.find(("pixelType")).asVocab32()==VOCAB_PIXEL_RGB))
            raw=false;
        else
        {
            yError()<<"DragonflyDeviceDriver2: invalid pixelType:"<<yarp::os::Vocab32::decode(config.find(("pixelType")).asVocab32());
            return false;
        }
    }
 
    system_resources=(void*)new CFWCamera_DR2_2(raw);
    if (!RES(system_resources)->Create(config))
    {
        fprintf(stderr,"DragonflyDeviceDriver2: can't open camera\n");
        return false;
    }
    
    return true;
}
 
bool DragonflyDeviceDriver2::close(void)
{
    if (system_resources)
    {
        RES(system_resources)->Close();
        return true;
    }
 
    return false;
}
 
bool DragonflyDeviceDriver2::getRawBuffer(unsigned char *buff)
{
    return RES(system_resources)->CaptureRaw(buff);
}
 
bool DragonflyDeviceDriver2::getRgbBuffer(unsigned char *buff)
{
    return RES(system_resources)->CaptureRgb(buff);
}
 
yarp::os::Stamp DragonflyDeviceDriver2::getLastInputStamp()
{
    return RES(system_resources)->getLastInputStamp();
}
 
int DragonflyDeviceDriver2::getRawBufferSize()
{
    return RES(system_resources)->getRawBufferSize();
}
 
int DragonflyDeviceDriver2::width () const
{
    return RES(system_resources)->width();
}
 
int DragonflyDeviceDriver2::height () const
{
    return RES(system_resources)->height();
}
 
// SET
 
bool DragonflyDeviceDriver2::setBrightness(double value)
{
    return RES(system_resources)->setBrightness(value);
}
bool DragonflyDeviceDriver2::setExposure(double value)
{
    return RES(system_resources)->setExposure(value);
}
bool DragonflyDeviceDriver2::setSharpness(double value)
{
    return RES(system_resources)->setSharpness(value);
}
bool DragonflyDeviceDriver2::setWhiteBalance(double blue, double red)
{
    return RES(system_resources)->setWhiteBalance(blue,red);
}
bool DragonflyDeviceDriver2::setHue(double value)
{
    return RES(system_resources)->setHue(value);
}
bool DragonflyDeviceDriver2::setSaturation(double value)
{
    return RES(system_resources)->setSaturation(value);
}
bool DragonflyDeviceDriver2::setGamma(double value)
{
    return RES(system_resources)->setGamma(value);
}
bool DragonflyDeviceDriver2::setShutter(double value)
{
    return RES(system_resources)->setShutter(value);
}
bool DragonflyDeviceDriver2::setGain(double value)
{
    return RES(system_resources)->setGain(value);
}
bool DragonflyDeviceDriver2::setIris(double value)
{
    return RES(system_resources)->setIris(value);
}
 
// GET
 
double DragonflyDeviceDriver2::getBrightness()
{
    return RES(system_resources)->getBrightness();
}
double DragonflyDeviceDriver2::getExposure()
{
    return RES(system_resources)->getExposure();
}
double DragonflyDeviceDriver2::getSharpness()
{
    return RES(system_resources)->getSharpness();
}
bool DragonflyDeviceDriver2::getWhiteBalance(double &blue, double &red)
{
    return RES(system_resources)->getWhiteBalance(blue,red);
}
double DragonflyDeviceDriver2::getHue()
{
    return RES(system_resources)->getHue();
}
double DragonflyDeviceDriver2::getSaturation()
{
    return RES(system_resources)->getSaturation();
}
double DragonflyDeviceDriver2::getGamma()
{
    return RES(system_resources)->getGamma();
}
double DragonflyDeviceDriver2::getShutter()
{
    return RES(system_resources)->getShutter();
}
double DragonflyDeviceDriver2::getGain()
{
    return RES(system_resources)->getGain();
}
double DragonflyDeviceDriver2::getIris()
{
    return RES(system_resources)->getIris();
}
 
// DC1394
 
bool DragonflyDeviceDriver2::hasFeatureDC1394(int feature)
{
    return RES(system_resources)->hasFeatureDC1394(feature);
}
bool DragonflyDeviceDriver2::setFeatureDC1394(int feature,double value)
{
    return RES(system_resources)->setFeatureDC1394(feature,value);
}
double DragonflyDeviceDriver2::getFeatureDC1394(int feature)
{
    return RES(system_resources)->getFeatureDC1394(feature);
}
bool DragonflyDeviceDriver2::hasOnOffDC1394(int feature)
{
    return RES(system_resources)->hasOnOffDC1394(feature);
}
bool DragonflyDeviceDriver2::setActiveDC1394(int feature, bool onoff)
{
    return RES(system_resources)->setActiveDC1394(feature,onoff);
}
bool DragonflyDeviceDriver2::getActiveDC1394(int feature)
{
    return RES(system_resources)->getActiveDC1394(feature);
}
bool DragonflyDeviceDriver2::hasAutoDC1394(int feature)
{
    return RES(system_resources)->hasAutoDC1394(feature);
}
bool DragonflyDeviceDriver2::hasManualDC1394(int feature)
{
    return RES(system_resources)->hasManualDC1394(feature);
}
bool DragonflyDeviceDriver2::hasOnePushDC1394(int feature)
{
    return RES(system_resources)->hasOnePushDC1394(feature);
}
bool DragonflyDeviceDriver2::setModeDC1394(int feature, bool auto_onoff)
{
    return RES(system_resources)->setModeDC1394(feature,auto_onoff);
}
bool DragonflyDeviceDriver2::getModeDC1394(int feature)
{
    return RES(system_resources)->getModeDC1394(feature);
}
bool DragonflyDeviceDriver2::setOnePushDC1394(int feature)
{
    return RES(system_resources)->setOnePushDC1394(feature);
}
unsigned int DragonflyDeviceDriver2::getVideoModeMaskDC1394()
{
    return RES(system_resources)->getVideoModeMaskDC1394();
}
bool DragonflyDeviceDriver2::setVideoModeDC1394(int video_mode)
{
    return RES(system_resources)->setVideoModeDC1394(video_mode);
}
unsigned int DragonflyDeviceDriver2::getVideoModeDC1394()
{
    return RES(system_resources)->getVideoModeDC1394();
}
unsigned int DragonflyDeviceDriver2::getFPSMaskDC1394()
{
    return RES(system_resources)->getFPSMaskDC1394();
}
unsigned int DragonflyDeviceDriver2::getFPSDC1394()
{
    return RES(system_resources)->getFPSDC1394();
}
bool DragonflyDeviceDriver2::setFPSDC1394(int fps)
{
    return RES(system_resources)->setFPSDC1394(fps);
}
unsigned int DragonflyDeviceDriver2::getISOSpeedDC1394()
{
    return RES(system_resources)->getISOSpeedDC1394();
}
bool DragonflyDeviceDriver2::setISOSpeedDC1394(int speed)
{
    return RES(system_resources)->setISOSpeedDC1394(speed);
}
unsigned int DragonflyDeviceDriver2::getColorCodingMaskDC1394(unsigned int video_mode)
{
    return RES(system_resources)->getColorCodingMaskDC1394(video_mode);
}
unsigned int DragonflyDeviceDriver2::getColorCodingDC1394()
{
    return RES(system_resources)->getColorCodingDC1394();
}
bool DragonflyDeviceDriver2::setColorCodingDC1394(int coding)
{
    return RES(system_resources)->setColorCodingDC1394(coding);
}
bool DragonflyDeviceDriver2::setWhiteBalanceDC1394(double b, double r)
{
    return RES(system_resources)->setWhiteBalanceDC1394(b,r);
}
bool DragonflyDeviceDriver2::getWhiteBalanceDC1394(double &b, double &r)
{
    return RES(system_resources)->getWhiteBalanceDC1394(b,r);
}
bool DragonflyDeviceDriver2::getFormat7MaxWindowDC1394(unsigned int &xdim,unsigned int &ydim,unsigned int &xstep,unsigned int &ystep,unsigned int &xoffstep,unsigned int &yoffstep)
{
    return RES(system_resources)->getFormat7MaxWindowDC1394(xdim,ydim,xstep,ystep,xoffstep,yoffstep);
}
bool DragonflyDeviceDriver2::setFormat7WindowDC1394(unsigned int xdim,unsigned int ydim,int x0,int y0)
{
    return RES(system_resources)->setFormat7WindowDC1394(xdim,ydim,x0,y0);
}
bool DragonflyDeviceDriver2::getFormat7WindowDC1394(unsigned int &xdim,unsigned int &ydim,int &x0,int &y0)
{
    return RES(system_resources)->getFormat7WindowDC1394(xdim,ydim,x0,y0);
}
bool DragonflyDeviceDriver2::setOperationModeDC1394(bool b1394b)
{
    return RES(system_resources)->setOperationModeDC1394(b1394b);
}
bool DragonflyDeviceDriver2::getOperationModeDC1394()
{
    return RES(system_resources)->getOperationModeDC1394();
}
bool DragonflyDeviceDriver2::setTransmissionDC1394(bool bTxON)
{
    return RES(system_resources)->setTransmissionDC1394(bTxON);
}
bool DragonflyDeviceDriver2::getTransmissionDC1394()
{
    return RES(system_resources)->getTransmissionDC1394();
}
/*
bool DragonflyDeviceDriver2::setBayerDC1394(bool bON)
{
    return RES(system_resources)->setBayerDC1394(bON);
}
bool DragonflyDeviceDriver2::getBayerDC1394()
{
    return RES(system_resources)->getBayerDC1394();
}
*/
bool DragonflyDeviceDriver2::setBroadcastDC1394(bool onoff)
{
    return RES(system_resources)->setBroadcastDC1394(onoff);
}
bool DragonflyDeviceDriver2::setDefaultsDC1394()
{
    return RES(system_resources)->setDefaultsDC1394();
}
bool DragonflyDeviceDriver2::setResetDC1394()
{
    return RES(system_resources)->setResetDC1394();
}
bool DragonflyDeviceDriver2::setPowerDC1394(bool onoff)
{
    return RES(system_resources)->setPowerDC1394(onoff);
}
bool DragonflyDeviceDriver2::setCaptureDC1394(bool bON)
{
    return RES(system_resources)->setCaptureDC1394(bON);
}
bool DragonflyDeviceDriver2::setBytesPerPacketDC1394(unsigned int bpp)
{
    return RES(system_resources)->setBytesPerPacketDC1394(bpp);
}
unsigned int DragonflyDeviceDriver2::getBytesPerPacketDC1394()
{
    return RES(system_resources)->getBytesPerPacketDC1394();
}
 
//IVisualParams
 
int DragonflyDeviceDriver2::getRgbHeight(){
    return RES(system_resources)->getRgbHeight();
}
 
int DragonflyDeviceDriver2::getRgbWidth(){
    return RES(system_resources)->getRgbWidth();
}
 
bool DragonflyDeviceDriver2::getRgbSupportedConfigurations(yarp::sig::VectorOf<CameraConfig> &configurations)
{
    return RES(system_resources)->getRgbSupportedConfigurations(configurations);
}
 
bool DragonflyDeviceDriver2::getRgbResolution(int &width, int &height)
{
    return RES(system_resources)->getRgbResolution(width,height);
}
 
bool DragonflyDeviceDriver2::setRgbResolution(int width, int height){
    if(width<=0 || height<=0){
        yError()<<"DragonflyDeviceDriver: invalid width or height";
        return false;
    }
    return RES(system_resources)->setRgbResolution(width,height);
}
 
bool DragonflyDeviceDriver2::getRgbFOV(double &horizontalFov, double &verticalFov){
    return RES(system_resources)->getRgbFOV(horizontalFov, verticalFov);
}
 
bool DragonflyDeviceDriver2::setRgbFOV(double horizontalFov, double verticalFov){
    return RES(system_resources)->setRgbFOV(horizontalFov, verticalFov);
}
 
bool DragonflyDeviceDriver2::getRgbIntrinsicParam(yarp::os::Property &intrinsic){
    return RES(system_resources)->getRgbIntrinsicParam(intrinsic);
}
 
bool DragonflyDeviceDriver2::getRgbMirroring(bool &mirror){
    return RES(system_resources)->getRgbMirroring(mirror);
 
}
 
bool DragonflyDeviceDriver2::setRgbMirroring(bool mirror){
    return RES(system_resources)->setRgbMirroring(mirror);
}
 
// IFrameGrabberControl2 //
 
bool DragonflyDeviceDriver2::getCameraDescription(CameraDescriptor* camera)
{
    camera->busType = BUS_FIREWIRE;
    camera->deviceDescription = "DragonFly2";
    return true;
}
 
bool DragonflyDeviceDriver2::getActive(int feature, bool* isActive)
{
    *isActive = RES(system_resources)->getActiveDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::getFeature(int feature, double* values)
{
    *values = RES(system_resources)->getFeatureDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::getMode(int feature, FeatureMode* mode)
{
    *mode = TRANSL_MODE( RES(system_resources)->getModeDC1394(feature) );
    return true;
}
 
bool DragonflyDeviceDriver2::hasAuto(int feature, bool* hasAuto)
{
    *hasAuto = RES(system_resources)->hasAutoDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::hasFeature(int feature, bool* hasFeature)
{
    *hasFeature = RES(system_resources)->hasFeatureDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::hasManual(int feature, bool* hasManual)
{
    *hasManual = RES(system_resources)->hasManualDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::hasOnePush(int feature, bool* hasOnePush)
{
    *hasOnePush = RES(system_resources)->hasOnePushDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::hasOnOff(int feature, bool* HasOnOff)
{
    *HasOnOff = RES(system_resources)->hasOnOffDC1394(feature);
    return true;
}
 
bool DragonflyDeviceDriver2::setActive(int feature, bool onoff)
{
    return RES(system_resources)->setActiveDC1394(feature,onoff);
}
 
bool DragonflyDeviceDriver2::setFeature(int feature, double value)
{
    return RES(system_resources)->setFeatureDC1394(feature, value);
}
 
bool DragonflyDeviceDriver2::getFeature(int feature, double* value1, double* value2)
{
    if(feature == YARP_FEATURE_WHITE_BALANCE)
        return RES(system_resources)->getWhiteBalanceDC1394(*value1, *value2);
    else
        return false;
}
 
bool DragonflyDeviceDriver2::setFeature(int feature, double value1, double value2)
{
    if(feature == YARP_FEATURE_WHITE_BALANCE)
        return RES(system_resources)->setWhiteBalanceDC1394(value1, value2);
    else
        return false;
}
 
bool DragonflyDeviceDriver2::setMode(int feature, FeatureMode mode)
{
    return RES(system_resources)->setModeDC1394(feature, TRANSL_MODE(mode));
}
 
bool DragonflyDeviceDriver2::setOnePush(int feature)
{
    return RES(system_resources)->setOnePushDC1394(feature);
}