SensorCollection Class Reference

#include <SensorColl.h>

Inheritance diagram for SensorCollection:

Collaboration diagram for SensorCollection:

Public Member Functions
	SensorCollection ()
	~SensorCollection ()
sensor_ptr	addSensor (const std::string &key, sensor_ptr s)
sensor_ptr	addSensor (sensor_ptr s)
sensor_ptr	readSensor (ParseFile &is)
sensor_ptr	getSensor (const std::string &id)
SensorCollection &	merge (SensorCollection &rhs)
bool	isPrinted (const std::string &id) const
void	setPrinted (const std::string &id)
void	clearPrintList (bool skipdefaults=true)
void	refModel (Model *model) const
void	unrefModel (Model *model) const
void	updateModels () const
void	selectSensor (const std::string &name)
const std::string &	getSelectedSensor () const

Protected Attributes
std::set< std::string >	m_Printlist
std::set< Model * >	m_Models
	references to attached geometry More...
std::string	m_SelSensor

Friends
std::ostream &	operator<< (std::ostream &os, const SensorCollection &sc)

Detailed Description

Definition at line 11 of file SensorColl.h.

Constructor & Destructor Documentation

SensorCollection::SensorCollection

(

)

Definition at line 16 of file SensorColl.cpp.

References getZeroSensor().

{
    addSensor(getZeroSensor()); // this is our zeroth sensor
}

SensorCollection::~SensorCollection

(

)

Definition at line 21 of file SensorColl.cpp.

{ }

Member Function Documentation

sensor_ptr SensorCollection::addSensor	(	const std::string &	key,
		sensor_ptr	s
	)

Definition at line 24 of file SensorColl.cpp.

Referenced by Model::attachDataset(), Brain::Brain(), Model::readSensor(), and Brain::triggerTest().

{
    s->setID(key);
    return addSensor(s);
}

sensor_ptr SensorCollection::addSensor

(

sensor_ptr

s

)

Definition at line 30 of file SensorColl.cpp.

References NULL, and SHOW.

                                                   {
    if(!s) return NULL;
    if(s->getID().empty()) return NULL; //s->setID(size());
    sensor_ptr &spr = operator[](s->getID());
    selectSensor(s->getID());
    if(spr == NULL) {
        spr = s;
        return s;
    }else {
        SHOW("replacing sensor "<<s->getID());
        if(spr->assignRef(s)) {
            SHOW("assigning");
            s->replaceBy(spr);
        } else {
            SHOW("replacing");
            spr->replaceBy(s);
            spr = s;
        }
        return spr;
    }
}

void SensorCollection::clearPrintList

(

bool

skipdefaults = true

)

Definition at line 66 of file SensorColl.cpp.

Referenced by operator<<().

{
    m_Printlist.clear();
    if(skipdefaults) {
        m_Printlist.insert("d0");
        m_Printlist.insert("0");
    }
}

const std::string& SensorCollection::getSelectedSensor ( ) const

inline

Definition at line 32 of file SensorColl.h.

References m_SelSensor.

Referenced by Brain::triggerTest().

    { return m_SelSensor; }

sensor_ptr SensorCollection::getSensor

(

const std::string &

id

)

Definition at line 52 of file SensorColl.cpp.

Referenced by Model::attachDataset(), Model::readNode(), Model::reattachSensors(), and Brain::triggerTest().

                                                       {
    iterator fs = find(id);
    if(fs != end()) {
        return fs->second;
    } else {
//             char sid[5];
//             Sensor::getNumberString(sid,id);
//             cout << "zeroing " << sid << endl;
        sensor_ptr zs = makeSensor<ZeroSensor>();
        zs->setID(id);
        return addSensor(zs);
    }
}

bool SensorCollection::isPrinted

(

const std::string &

id

)

const

Definition at line 75 of file SensorColl.cpp.

Referenced by Sensor::hprint(), CombiSensor::hprint(), and operator<<().

{
    return m_Printlist.find(id) != m_Printlist.end();
}

SensorCollection & SensorCollection::merge

(

SensorCollection &

rhs

)

Definition at line 256 of file SensorColl.cpp.

References Sensor::replaceBy().

Referenced by Model::mergeSensorCollection().

{
    if(this == &rhs) return *this;
    for(map<string, sensor_ptr >::iterator si = rhs.begin();
        si != rhs.end(); si++)
    {
        if(!si->first.empty() && si->first!="0") {
            sensor_ptr spr = operator[](si->first); // sensor from lhs of collection assignment
            if(!spr) {
                spr = si->second;
            } else {
                bool lnzs = !std::dynamic_pointer_cast<ZeroSensor>(spr); // lhs sensor not zero
                bool rnzs = !std::dynamic_pointer_cast<ZeroSensor>(si->second); // rhs sensor not zero
                // TODO: inverted original logic, test if still valid
                if(rnzs) {
                    spr->replaceBy(si->second);
                    // spr = si->second;
                } else {
                    si->second->replaceBy(spr);
                }
            }
        }
    }
    return *this;
}

sensor_ptr SensorCollection::readSensor

(

ParseFile &

is

)

Definition at line 101 of file SensorColl.cpp.

References ParseFile::getKey(), ParseFile::getNextLine(), ParseFile::getValue(), getZeroSensor(), NULL, ParseFile::pushLine(), ParseFile::setParseError(), and SHOW.

Referenced by Model::readSensor().

{
    if(!is.getNextLine()) return NULL;
    if(is.getKey() != "s") {
        is.pushLine();
        return NULL;
    }
    istringstream vs(is.getValue());
    vs >> ws;       // read key
    string skey;
    //vs.width(2047);
    vs >> skey;
    vs >> ws;       // read type
    string para1;
    vs >> para1;
    char stype;
    sensor_cptr source = NULL;
    if (para1 == "source") {
        string sname;
        vs >> sname;
        source = getSensor(sname);
        if(std::dynamic_pointer_cast<const ZeroSensor>(source))
            cout << "Using zero sensor as source. Source name was: "
                 << sname <<endl;
        else {
            SHOW("Using source " << source->getID());
        }
        vs >> stype;
    } else {
        stype = para1[0];
    }
    if(source == NULL) {
        source = getSensor(string("d0"));
    }
    sensor_ptr s = NULL;
    switch(stype) {
    case 'i' :
        s = makeSensor<IntensitySensor>(source);
        SHOW("created intensity sensor");
        break;
    case 'g' :
    {
        float scale=0;
        vs >> scale;
        s = makeSensor<SmoothIntensitySensor>(source, scale);
        SHOW("created Gaussian sensor of scale " << scale);
        break;
    }
    case 'd' :
    {
        //float scale=0;
        //vs >> scale;
        s = makeSensor<GradMagSensor>(source);
        SHOW("created gm sensor");// of scale " << scale);
        break;
    }
    case 'c' :
    {
//      float scale=0;
//      vs >> scale;
        s = makeSensor<CornerSensor>(source);
        SHOW("created corner sensor");// of scale " << scale);
        break;
    }
    case 'K' :
        s = makeSensor<CombiSensor>();
        std::dynamic_pointer_cast<CombiSensor>(s)->normalizeInput(false);
        // is legally constructed in the next case 'k'
    case 'k' :
    {
        int nsensors=0;
        //vs >> nsensors;
        if(!s) s = makeSensor<CombiSensor>();       //normalized input
        string sname;
        while(vs >> sname) {
            float weight=1;
            vs >> weight;
            sensor_ptr ss = getSensor(sname);
            if(ss == getZeroSensor())
                cout << "added zero sensor" << endl;
            std::dynamic_pointer_cast<CombiSensor>(s)->setSource(ss,weight);
            nsensors++;
        }
        SHOW("created combi sensor with " << nsensors<<" sub-sensors.");
        break;
    }
    case 'm' :
    {
        int nc = source ? source->getNChannels() : 0;
        vector<float> weights;
        weights.reserve(nc);
        float weight=1;
        while(vs >> weight) {
            weights.push_back(weight);
            cout << weight << " ";
        }
        cout << endl;
        s = makeSensor<MCIntensitySensor>(source);
        s->setCWeights(weights);
        SHOW("created multi-channel sensor.");
        break;
    }
    case 'M' :
    {
        s = makeSensor<MCGSensor>(source);
        SHOW("created multi-channel gradient sensor.");
        break;
    }
    case 'r' :
    {
        s = makeSensor<CRSensor>(source);
        SHOW("created multi-channel chrominance sensor.");
        break;
    }
    case 'C' :
    {
        string fname;
        vs >> fname;
        if(!fname.empty()) {
            s = makeSensor<MahalSensor>(source, fname);
            if(!std::dynamic_pointer_cast<MahalSensor>(s)->getFilename().empty()) {
                SHOW("created colour classification sensor");
            } else {
                SHOW("error loading configuration file for colour sensor "
                     << fname);
                s = sensor_ptr();
            }
        }
        break;
    }
    case 'f' :
    {
        string mapping;
        vs >> mapping;
        s = makeSensor<MappingSensor>(source, mapping);
        std::dynamic_pointer_cast<MappingSensor>(s)->readParams(vs);
        SHOW("created mapping sensor of type " <<
             std::dynamic_pointer_cast<MappingSensor>(s)->getMappingName());
        break;
    }
    case 'o' :
    {
        s = makeSensor<ZeroSensor>();
        SHOW("created zero sensor");
        break;
    }
    }
    if(!s) {
        is.setParseError(string("unknown sensor type ")+stype);
        throw new IOException("Error reading sensor.");
    }
    s->setID(skey);
    return s;
}

void SensorCollection::refModel

(

Model *

model

)

const

Definition at line 282 of file SensorColl.cpp.

Referenced by Model::attachSensorColl(), and Model::Model().

{
    m_Models.insert(model);
}

void SensorCollection::selectSensor ( const std::string &  name )

inline

Definition at line 30 of file SensorColl.h.

References m_SelSensor.

    { m_SelSensor = name; }

void SensorCollection::setPrinted

(

const std::string &

id

)

Definition at line 80 of file SensorColl.cpp.

Referenced by Sensor::hprint(), and CombiSensor::hprint().

{
    m_Printlist.insert(id);
}

void SensorCollection::unrefModel

(

Model *

model

)

const

Definition at line 287 of file SensorColl.cpp.

Referenced by Model::attachSensorColl().

{
    m_Models.erase(model);
}

void SensorCollection::updateModels

(

)

const

Definition at line 292 of file SensorColl.cpp.

Referenced by Brain::load(), Brain::loadModel(), and Brain::triggerTest().

{
    for(set<Model*>::iterator mo = m_Models.begin();
        mo != m_Models.end(); mo++)
        (*mo)->reattachSensors();
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const SensorCollection &  sc  )

friend

Definition at line 85 of file SensorColl.cpp.

{
    ((SensorCollection*)&sc)->m_Printlist.clear();
    for(map<string,sensor_ptr>::const_iterator s=sc.begin(); s!=sc.end(); s++) {
        if (s->second->getID() != "0"       && // zero sensor
            !s->second->getID().empty()     && // uninitialized sensor
            s->second->getID() != "d0"      &&
            !sc.isPrinted(s->second->getID())
            )
        {
            s->second->hprint(os, (SensorCollection*)&sc);
        }
    }
    return os;
}

Member Data Documentation

std::set<Model*> SensorCollection::m_Models

mutableprotected

references to attached geometry

Definition at line 36 of file SensorColl.h.

std::set<std::string> SensorCollection::m_Printlist

protected

Definition at line 35 of file SensorColl.h.

std::string SensorCollection::m_SelSensor

protected

Definition at line 37 of file SensorColl.h.

Referenced by getSelectedSensor(), and selectSensor().

---

The documentation for this class was generated from the following files:

• src/SensorColl.h
• src/SensorColl.cpp