Brain Class Reference

#include <Brain.h>

Inheritance diagram for Brain:

Collaboration diagram for Brain:

Public Types
enum	RunWhat { DO_ANIMATE, DO_NOTHING, DO_ANALYSIS, DO_LAST }
	some options for run(whatsup) More...

Public Member Functions
	Brain ()
	~Brain ()
bool	load (const char *bfile)
bool	loadModel (const char *filename)
bool	loadData (const char *filename, dword ppmm=0)
bool	loadDB (const char *filename)
bool	loadDBSelector (const char *filename)
bool	loadSpecies (const Species &spec)
const Model &	getModel ()
const Dataset &	getData () const
Dataset &	getSensorData ()
void	attachBrowseData ()
void	drawAllModels () const
bool	triggerTest (int mx, int my, int what=0)
bool	doCommand (const std::string &command, const std::string &value, int mx=0, int my=0)
bool	isDone () const
void	run (int whatsup, void *data)
	virtual from vuThread More...
dword	duplicateState (const Model *model=NULL)
bool	switchState (dword newstate)
void	killState (dword state)
void	killAllStates ()
void	killCurrentState ()
void	toggleUpdateForAll (bool onoff=true)
void	evolve (float dt)
void	findWinners ()
const SensorCollection &	getSensors () const
SensorCollection &	getSensors ()
void	getQualityRange (float &lqof, float &hqof, float shapeweight=-1) const
int	distributeModel (const Model &model, int n=-1, float qth=0, bool count=false)
bool	changeModel (const std::string &mname)
bool	mergeInstances ()
template<class Iter >
dword	getAllModels (Iter iter)
vuMutex &	getGeomMutex ()
Public Member Functions inherited from vuThread
virtual	~vuThread ()
	Virtual destructor (doing nothing) More...
bool	startThread (int whatsup, void *data=NULL)
void	stopThread ()

Protected Types
enum	SearchWhat {   SW_UB, SW_LB, SW_RESET, SW_SET,   SW_SPREAD }

Protected Member Functions
int	getBindex (int bx, int by, bool &culled=*((bool *) NULL))
void	setupSearch (enum SearchWhat what=SW_RESET, const PropVec &prop=PropVec())

Protected Attributes
dataset_ptr	m_Data
dataset_ptr	m_BrowseData
SensorCollection	m_Sensors
Model *	m_Geom
std::vector< Model * > *	m_CStates
std::map< std::string, Model * >	m_Prototypes
std::map< std::string, std::vector< Model * > >	m_Instances
std::string	m_CurPrototype
dword	m_CurState
SpeciesDB	m_DB
DBSelector	m_DBSelector
Species	m_CSpecies
float	m_TimeStep
float	m_TimeScale
bool	m_UpdateAllModels
vuMutex	m_GeomMutex
vuMutex	m_DataMutex
vuMutex	m_RunMutex [DO_LAST]
bool	m_ThreadActive [DO_LAST]
bool	m_Done
bool	m_DesignMode
bool	m_ImmediateData
bool	m_DrawOwnState
Searcher	m_Search
std::list< Model >	m_Winners
StructTable	m_SModel

Additional Inherited Members
Static Public Member Functions inherited from vuThread
static void	usleep (unsigned long ms)
	sleep for n microseconds (!!not yet implemented for win32) More...

Detailed Description

Definition at line 27 of file Brain.h.

Member Enumeration Documentation

enum Brain::RunWhat

some options for run(whatsup)

Enumerator
DO_ANIMATE
DO_NOTHING
DO_ANALYSIS
DO_LAST

Definition at line 52 of file Brain.h.

{ DO_ANIMATE, DO_NOTHING, DO_ANALYSIS, DO_LAST};

enum Brain::SearchWhat

protected

Enumerator
SW_UB
SW_LB
SW_RESET
SW_SET
SW_SPREAD

Definition at line 85 of file Brain.h.

{SW_UB, SW_LB, SW_RESET, SW_SET, SW_SPREAD };

Constructor & Destructor Documentation

Brain::Brain

(

)

Definition at line 27 of file Brain.cpp.

References SensorCollection::addSensor(), DO_ANIMATE, DO_LAST, Model::getName(), m_BrowseData, m_CStates, m_CurPrototype, m_CurState, m_Data, m_DesignMode, m_Done, m_Geom, m_ImmediateData, m_Sensors, m_ThreadActive, and vuThread::startThread().

             : m_DBSelector(m_DB), m_TimeStep(TIMESTEP), m_TimeScale(1),
                 m_UpdateAllModels(false), m_DrawOwnState(false),
                 m_SModel(*this)
{
    m_Data = std::make_shared<Dataset>();
    m_BrowseData = std::make_shared<Dataset>();
    m_Done = false;
    m_Sensors.addSensor("d0", m_Data);
    m_Geom = new Model(m_Data, &m_Sensors);
    m_CStates = new vector<Model*>; //&m_Instances[m_Geom->getName()];
    m_CurPrototype = m_Geom->getName();
    m_CStates->push_back(m_Geom);
    m_CurState=0;
    m_DesignMode = false;
    m_ImmediateData = false;
    for(int i = 0; i<DO_LAST; i++) m_ThreadActive[i] = false;
    startThread(Brain::DO_ANIMATE);
}

Brain::~Brain

(

)

Definition at line 46 of file Brain.cpp.

References DO_LAST, vuMutex::lock(), m_CStates, m_GeomMutex, m_RunMutex, m_ThreadActive, NULL, and vuMutex::unlock().

{
    for(int i = 0; i<DO_LAST; i++)
        if(m_ThreadActive[i]) m_RunMutex[i].lock();
    // will be unlocked by the thread
    for(int i = 0; i<DO_LAST; i++)
        if(m_ThreadActive[i]) m_RunMutex[i].lock();
    for(int i = 0; i<DO_LAST; i++)
        if(m_ThreadActive[i]) m_RunMutex[i].unlock();
    m_GeomMutex.lock();
//     for(map<string, vector<Model*> >::iterator ii = m_Instances.begin();
//         ii != m_Instances.end(); ii++)
//     {
//         changeModel(ii->first);
    if(m_CStates) {
        for(vector<Model*>::iterator gi=m_CStates->begin();
            gi!=m_CStates->end(); gi++)
        {
            delete *gi;
        }
        delete m_CStates;
        m_CStates = NULL;
    }
//    }
//     for(map<string,Model*>::iterator gi=m_Prototypes.begin();
//         gi!=m_Prototypes.end(); gi++)
//     {
//         delete gi->second;
//     }
}

Member Function Documentation

void Brain::attachBrowseData

(

)

Definition at line 300 of file Brain.cpp.

References StructTable::adaptDataScale(), getAllModels(), m_BrowseData, m_Data, m_SModel, and setupSearch().

Referenced by getModel(), loadData(), run(), and triggerTest().

{
    if(m_Data->getFilename() == m_BrowseData->getFilename()) {
        cout << "dataset already attached" << endl;
        return;
    }
    cout << "attaching data..." << endl;
    m_Data->copyData(*m_BrowseData);
    list<Model*> ml;
    if(getAllModels(back_inserter(ml))) {
        for(list<Model*>::iterator m=ml.begin(); m!=ml.end(); m++)
            (*m)->adaptDataScale();
    }
    m_SModel.adaptDataScale();
    setupSearch();
    cout << "attaching data done." << endl;
}

bool Brain::changeModel

(

const std::string &

mname

)

change container to prototype of name mname

Definition at line 231 of file Brain.cpp.

References m_CStates, m_CurPrototype, m_Instances, and switchState().

Referenced by getSensors(), and mergeInstances().

                                           {
    return false;
#if 0
    m_CurPrototype = mname;
    m_CStates = &m_Instances[mname];
    switchState(0);
    return true;
#else
    map<string, vector<Model*> >::iterator fs =
        m_Instances.find(mname);
    if(fs != m_Instances.end()) {
//         iterator map<string, vector<Model*> >::iterator os =
//             m_Instances.find(m_CurPrototype);
//         if(os->first) {
//             os->second = m_CStates;
//         }
        m_CStates = &fs->second;
        m_CurPrototype = mname;
        switchState(0);
        return true;
    } else {
        m_Instances[mname].resize(0);
        m_CStates = &m_Instances[mname];
        m_CurPrototype = mname;
        //m_Geom is invalid now!
        return false;
    }
#endif
}

int Brain::distributeModel	(	const Model &	model,
		int	n = -1,
		float	qth = 0,
		bool	count = false
	)

Definition at line 1299 of file Brain.cpp.

References __SHAPEWEIGHT, duplicateState(), fgauss01(), frand, Model::getCenter(), Model::getQualityOfFit(), Model::getStdRadius(), killCurrentState(), m_CurState, m_Data, m_Geom, M_PI, Model::rotate(), Model::scale(), Model::setShapeWeight(), switchState(), and Model::translate().

Referenced by getSensors(), and triggerTest().

{
    int cstate = m_CurState;
    int i;
    int cs=0;
    int dist = (int)model.getStdRadius()+1;
    int sx = m_Data->getDim1Size()/dist;
    int sy = m_Data->getDim2Size()/dist;
    if(n==0) {  // jittering
        int j;
        for(j=0; j<m_Data->getDim2Size(); j+=dist)
            for(i=0; i<m_Data->getDim1Size(); i+=dist)
            {
                duplicateState(&model);
                Point p(i,j);
                p += Point(frand(dist), frand(dist)); // jittering
                m_Geom->translate(p-m_Geom->getCenter());
                m_Geom->rotate(frand(2*M_PI));
                m_Geom->scale(max(fgauss01()*0.3f+1.f, 0.1f),true);
                m_Geom->setShapeWeight(__SHAPEWEIGHT);
                if(m_Geom->getQualityOfFit() < qth) {
                    killCurrentState();
                } else cs++;
            }
    } else { // monte carlo
        if(n<0)
            n = (int)(m_Data->getDim1Size()*m_Data->getDim2Size()/(dist*dist));
        for(i=0; i<n; i++) {
            duplicateState(&model);
            Point p(frand(m_Data->getDim1Size()),  // monte carlo
                    frand(m_Data->getDim2Size()));
            m_Geom->translate(p-m_Geom->getCenter()); //random position
            m_Geom->rotate(frand(2*M_PI)); //rand. orient.
            m_Geom->scale(max(fgauss01()*0.3f+1.f, 0.1f),true);
            m_Geom->setShapeWeight(__SHAPEWEIGHT);
            if(m_Geom->getQualityOfFit() < qth) {
                killCurrentState();
                if(count) i--;
            } else cs++;
        }
    }
    switchState(cstate);
    return cs;
}

bool Brain::doCommand	(	const std::string &	command,
		const std::string &	value,
		int	mx = 0,
		int	my = 0
	)

Definition at line 1150 of file Brain.cpp.

References dmutil::abs(), MStructure::buildAllStats(), Species::CMP_GREATER, DO_ANALYSIS, DUMP, fromString(), DBSelector::getCurSpecies(), Model::getDirNode(), SpeciesDB::getFilename(), Species::getFlagString(), Node::getIndex(), MStructure::getInfoFilename(), StructTable::getNextStruct(), Model::getProperties(), MStructure::getRefModelIDs(), Species::getScale(), getSearchPara(), Species::id, loadSpecies(), m_BrowseData, m_CSpecies, m_DB, m_DBSelector, m_Geom, m_SModel, DBSelector::nextSelection(), Model::readFile(), Species::readFlagString(), SpeciesDB::select(), Model::setDirNode(), MStructure::setRefModel(), MStructure::setRefProp(), vuThread::startThread(), toString(), and SearcherParams::write().

Referenced by getModel(), and triggerTest().

{
    if(command == "savedb") {
        ofstream os(m_DB.getFilename().c_str());
        if(os) {
            cout << "saving " << m_DB.getFilename();
            os << m_DB;
            os.close();
            cout << " done." << endl;
        } else cout << "Could not create " << m_DB.getFilename()<<endl;
    } else if(command == "scale0" || command == "scale1" ||
              command == "scaleh" || command == "scaled") {
        static int oldmx = -1;
        static float scale = 1;
        if(command == "scaleh") scale *= 0.5;
        else if(command == "scaled") scale *= 2;
        cout << "using scale " << scale << " mm" << endl;
        if(command == "scale0") oldmx = mx;
        else if(command == "scale1") {
            m_DBSelector.getCurSpecies()["scale"] =
                toString(abs(mx-oldmx)/scale);
            cout << m_DBSelector.getCurSpecies().getScale()
                 << " pixels per mm" << endl;
        }
    } else if(command == "flags") {
        m_DBSelector.getCurSpecies().readFlagString(value);
        cout << endl << "new flags are <"
             << m_DBSelector.getCurSpecies().getFlagString()
             << ">" << endl;
    } else if(command == "go") {
        dword id; fromString(value, id);
        //m_DB.select(Species(id));
        loadSpecies(m_DB[id]);
    } else if(command == "calstat") {
        MStructure& st = m_SModel.getNextStruct(0);
        st.buildAllStats();
    } else if(command == "selall") {
        dword nsel = m_DB.select(Species(), Species::CMP_GREATER);
        cout << "selected all " << nsel
             << " species in data base" << endl;
    } else if(command == "process") {
        MStructure& st = m_SModel.getNextStruct(0);
        if(!*m_Geom) {
            m_DBSelector.nextSelection(0);
            loadSpecies(m_DBSelector.getCurSpecies());
            dword firstid = 0;
            while(m_CSpecies.id != firstid) {
                if(!firstid) firstid = m_CSpecies.id;
                if(m_BrowseData->getPPMM()) {
                    cout << "setting reference frame for species id "
                         << m_CSpecies.id << endl;
                    PropVec frameprop(m_BrowseData->getPropVecMM());
                    DUMP(frameprop);
                    st.setRefProp(m_CSpecies.id, frameprop);
                }
                m_DBSelector.nextSelection(1);
                loadSpecies(m_DBSelector.getCurSpecies());
            }
        }
    } else if(command == "setdir") {
        if(value.empty()) {
            cout << "current dir node: "
                 << m_Geom->getDirNode().getIndex() << endl;
        } else {
            int dirnode; fromString(value, dirnode);
            MStructure& st = m_SModel.getNextStruct(0);
            list<dword> refmod;
            st.getRefModelIDs( back_inserter(refmod) );
            cout << m_DB.select(refmod) << " species selected" << endl;
            Model model; // not attached to anything
            for(list<dword>::const_iterator idi = refmod.begin();
                idi != refmod.end(); idi++) {
                model.readFile(
                    st.getInfoFilename(toString(*idi)).c_str());
                DUMP(model.getProperties());
                DUMP(model.getDirNode().getIndex());
                model.setDirNode(dirnode);
                DUMP(model.getProperties());
                DUMP(model.getDirNode().getIndex());
                st.setRefModel(*idi, model);
            }
        }
    } else if(command == "savesearcher") {
        string fname = value.empty() ? "searcher.cnf" : value;
        ofstream os(fname.c_str());
        getSearchPara().write(os, true);
    } else if(command == "hbs") {
        dword hbs; fromString(value, hbs);
        m_BrowseData->setHalveBeyondSize(hbs);
        cout << "image resolution is halved beyond a size of "
             << m_BrowseData->getHalveBeyondSize() << endl;
    } else if(command == "analysis") {
        intptr_t para=0; fromString(value, para);
        startThread(DO_ANALYSIS, (void*)para);
    } else if(command == "noise") {
        cout << "going for noise" << endl;
        float para=255.f; fromString(value, para);
        m_BrowseData->addNoise(para);
    } else {
        cout << "command not recognized" << endl;
        return false;
    }
    return true;
}

void Brain::drawAllModels

(

)

const

Definition at line 1344 of file Brain.cpp.

References Searcher::draw(), StructTable::draw(), Model::draw(), StructTable::getIPaths(), Model::getQualityOfFit(), getQualityRange(), StructTable::getShownIP(), m_BrowseData, m_CStates, m_Data, m_DataMutex, m_DesignMode, m_DrawOwnState, m_Geom, m_GeomMutex, m_Search, m_SModel, sglBitmapString(), sglBitmapStringOutlined(), Point2D::x, and Point2D::y.

Referenced by getModel().

                                {
    vuLock glock((vuMutex&)m_GeomMutex);
    vuLock dlock((vuMutex&)m_DataMutex);
//draw winners
    m_Search.draw();
    m_SModel.draw();
    if(m_DrawOwnState) {
        if(m_CStates->empty()) return;
        float lqof,hqof;
        getQualityRange(lqof,hqof);
        if(lqof>0) lqof=0;
        //TRACE("qmin="<<lqof<<" qmax="<<hqof);
        if(!m_DesignMode) {
//draw instances
            glLineWidth(1.0f);
            for(vector<Model*>::const_iterator m = m_CStates->begin();
                m!=m_CStates->end(); m++)
            {
                if(m_Geom != *m) {
                    float alpha = (hqof!=0.0) ? ((*m)->getQualityOfFit()-lqof)/hqof :0;
                    alpha = alpha*0.8+0.2;
                    glColor4f(0.1,0.2,0.9,alpha);
                    (*m)->draw();
                }
            }

        } else {  // is design mode
            glColor3f(1,1,0);
            sglBitmapString("design mode",10,20);
        }

//draw selected one
        float alpha=0.0;
        if(hqof!=0.0)
            alpha = (m_Geom->getQualityOfFit()-lqof)/hqof;
        alpha = alpha*0.6+0.4;
        glEnable(GL_LINE_SMOOTH);    // looks nice but BIG performace killer
        //glColor4f(0.0f, 0.0f, 1.0f,alpha);
        glColor4f(0.0f, 0.0f, 0.0f,alpha);
        glLineWidth(5.0f);
        m_Geom->draw(m_DesignMode);
        glLineWidth(3.0f);
        glColor4f(1.0f, 1.0f, 1.0f,alpha);
        m_Geom->draw(m_DesignMode);
        glDisable(GL_LINE_SMOOTH);    // looks nice but BIG performace killer
        //cout << (m_Geom->getQualityOfFit()) << endl;

//draw names
#ifdef _DRAW_MODEL_NAMES_
        for(vector<Model*>::const_iterator m = m_CStates->begin();
            m!=m_CStates->end(); m++)
        {
            if((*m)->isWinner() || (*m) == m_Geom ) {
                Point c = (*m)->getCenter();
                stringstream descr;
                descr << (*m)->getName();// << " " << (*m)->getLiveliness();
                sglBitmapStringOutlined(descr.str().c_str(),(int)c.x,(int)c.y);
            }
        }
#endif
    } // of draw own state
    {
        glLineWidth(1.0f);
        glColor3f(1,1,1);
        map<string,StructPath>::const_iterator spath =
            m_SModel.getIPaths().find(m_SModel.getShownIP());
        if(spath != m_SModel.getIPaths().end()) {
            stringstream descr;
            descr << m_SModel.getShownIP() << " ";
            descr << spath->second.getRelGoodness();
            sglBitmapString(descr.str().c_str(),10,m_Data->getDim2Size()-20);
        }
//    sglBitmapString(m_CurPrototype.c_str(),10,m_Data->getDim2Size()-20);
    }
    if(m_Data->getFilename() != m_BrowseData->getFilename()) {
        glColor3f(1,1,0);
        sglBitmapString("SENSORS NOT ATTACHED!",10,40);
    }
}

dword Brain::duplicateState

(

const Model *

model = NULL

)

duplicate state of current model

Returns

ID of copy

Definition at line 1267 of file Brain.cpp.

References m_CStates, m_CurState, and m_Geom.

Referenced by distributeModel(), evolve(), and triggerTest().

                                              {
    if(!model) model = m_Geom;
    m_Geom = new Model(*model);
    m_CStates->push_back(m_Geom);
    m_CurState = m_CStates->size()-1;
    return m_CurState;
/*
  m_CStates->push_back(new Model(*m_Geom));
  return m_CStates->size()-1;
  TRACE(m_CurState);
*/
}

void Brain::evolve

(

float

dt

)

Definition at line 1424 of file Brain.cpp.

References duplicateState(), Searcher::evolve(), frand, Model::getCenter(), Model::getQualityOfFit(), getQualityRange(), getSearchPara(), Model::getStdRadius(), killState(), m_CStates, m_CurState, m_Data, m_Done, m_Geom, m_Search, m_SModel, Searcher::step(), StructTable::stepSearch(), switchState(), and Model::translate().

Referenced by run(), and toggleUpdateForAll().

{
    if(m_Done || !m_Data->initialized()) return;

    static float t=0;
    t+=dt;

    m_SModel.stepSearch(dt);

    static float search_evolve_t = 0;
    if(t-search_evolve_t > getSearchPara().m_EvolveCycle) {
        m_Search.evolve();
        search_evolve_t = t;
    }
    m_Search.step(dt);

    return;

// determine range of qualities
    float lqof,hqof;
    getQualityRange(lqof,hqof);
    //if(lqof>0) lqof=0;

//remove bad ones
    static float kill_t = 0;
    if(t-kill_t > 6) {
        float kill_quality_th = 0.1;
        for(int mi=0; mi<(int)m_CStates->size()
                && (int)m_CStates->size()>1;)
        {
            Model *m = (*m_CStates)[mi];
            float relq = (hqof!=0.0) ? (m->getQualityOfFit()-lqof)/hqof :1;
            if(relq < kill_quality_th) {
                //TRACE(relq);
                killState(mi);
            }else mi++;
        }
        kill_t = t;
    }

//create some (not used yet)
    //TRACE("min "<<lqof<<" max "<<hqof);
    if(0 && hqof-lqof < 0.001 && m_Geom->getNNodes()>0) {
        static bool duplicated=false;
        if(duplicated && hqof-lqof>0) m_Done = true;
        else {
            duplicated = true;
            int cstate = m_CurState;
            int dist = (int)(1.5*m_Geom->getStdRadius());
            int i,j;
            for(j=dist/2;j<m_Data->getDim2Size(); j+=dist)
                for(i=dist/2;i<m_Data->getDim1Size(); i+=dist) {
                    duplicateState();
                    m_Geom->translate(Point(i,j)-m_Geom->getCenter());
                }
            switchState(cstate);
        }
    }

//randomize bad ones
    static float laze_t = 0;
    //static bool lazing = true;
    static float change_t = 0;
    if(t-change_t > 0.2)
    {
        if(t-laze_t < 1) {
            float change_quality_th = 0.7;
            for(vector<Model*>::iterator m=m_CStates->begin();
                m!=m_CStates->end();m++)
            {
                float relq = (hqof!=0.0) ? ((*m)->getQualityOfFit()-lqof)/hqof :1;
                //TRACE((*m)->getLiveliness());
                if(relq < change_quality_th && (*m)->getLiveliness()<1) {
                    (*m)->pushRotate((*m)->getCenter(), -1+frand(2));
                    (*m)->addNoise(0.05);
                }
            }
        } else if(t-laze_t > 3) laze_t = t;
        change_t = t;
    }
}

void Brain::findWinners

(

)

Referenced by toggleUpdateForAll().

template<class Iter >

dword Brain::getAllModels ( Iter  iter )

inline

Definition at line 116 of file Brain.h.

References m_CStates.

Referenced by attachBrowseData(), and getSensors().

{
    dword nm=0;
    if(m_CStates)
        for(std::vector<Model*>::iterator mi = m_CStates->begin();
            mi != m_CStates->end(); mi++)
        {
            *iter++ = *mi;
            nm++;
        }
//     for(std::map<std::string, std::vector<Model*> >::iterator
//         ti=m_Instances.begin(); ti != m_Instances.end(); ti++) {
//         for(std::vector<Model*>::iterator gi=ti->second.begin();
//             gi!=ti->second.end(); gi++)
//         {
//             *iter++ = *gi;
//             nm++;
//         }
//     }
//     for(std::map<std::string,Model*>::iterator gi=m_Prototypes.begin();
//         gi!=m_Prototypes.end(); gi++)
//     {
//         *iter++ = gi->second;
//         nm++;
//     }
    return nm;
}

int Brain::getBindex ( int  bx, int  by, bool &  culled = *((bool *) NULL)  )

protected

Referenced by getGeomMutex().

const Dataset & Brain::getData

(

)

const

Definition at line 77 of file Brain.cpp.

References m_BrowseData.

Referenced by getModel().

{
    return *m_BrowseData;
}

vuMutex& Brain::getGeomMutex ( )

inline

Definition at line 82 of file Brain.h.

References getBindex(), m_GeomMutex, and NULL.

{ return m_GeomMutex; }

const Model& Brain::getModel ( )

inline

Definition at line 39 of file Brain.h.

References attachBrowseData(), doCommand(), drawAllModels(), getData(), getSensorData(), m_Geom, and triggerTest().

{return *m_Geom;}

void Brain::getQualityRange	(	float &	lqof,
		float &	hqof,
		float	shapeweight = -1
	)		const

Definition at line 1506 of file Brain.cpp.

References m_CStates.

Referenced by drawAllModels(), evolve(), getSensors(), and triggerTest().

{
    bool cw = (shapeweight!=-1);
    if(cw) (*m_CStates->begin())->setShapeWeight(shapeweight);
    lqof=hqof=(*m_CStates->begin())->getQualityOfFit();
    for(vector<Model*>::const_iterator m = m_CStates->begin();
        m!=m_CStates->end(); m++)
    {
        if(cw)(*m)->setShapeWeight(shapeweight);
        if((*m)->getQualityOfFit()>hqof) hqof=(*m)->getQualityOfFit();
        if((*m)->getQualityOfFit()<lqof) lqof=(*m)->getQualityOfFit();
    }
}

Dataset & Brain::getSensorData

(

)

Definition at line 82 of file Brain.cpp.

References m_Data.

Referenced by getModel().

{
    return *m_Data;
}

const SensorCollection& Brain::getSensors ( ) const

inline

Definition at line 70 of file Brain.h.

References m_Sensors.

{ return m_Sensors; }

SensorCollection& Brain::getSensors ( )

inline

Definition at line 71 of file Brain.h.

References changeModel(), distributeModel(), getAllModels(), getQualityRange(), m_Sensors, and mergeInstances().

{ return m_Sensors; }

bool Brain::isDone ( ) const

inline

Definition at line 49 of file Brain.h.

References m_Done.

{ return m_Done; }

void Brain::killAllStates

(

)

Definition at line 1291 of file Brain.cpp.

References killState(), m_CStates, and m_CurState.

Referenced by triggerTest().

                          {
    //done in sub-procedure vuLock glock(m_GeomMutex);
    while(m_CStates->size()>1) {
        if(m_CurState==0) killState(1);
        else killState(0);
    }
}

void Brain::killCurrentState ( )

inline

Definition at line 63 of file Brain.h.

References killState(), and m_CurState.

Referenced by distributeModel(), and triggerTest().

{ killState(m_CurState); }

void Brain::killState

(

dword

state

)

Definition at line 1280 of file Brain.cpp.

References m_CStates, m_CurState, and switchState().

Referenced by evolve(), killAllStates(), killCurrentState(), and triggerTest().

                                 {
    if(state>=m_CStates->size()) return;
    if(m_CStates->size() == 1) return;
    else {
        delete (*m_CStates)[state];
        m_CStates->erase(m_CStates->begin()+state);
    }
    if(state<=m_CurState) m_CurState--;
    switchState(m_CurState);
}

bool Brain::load

(

const char *

bfile

)

Definition at line 87 of file Brain.cpp.

References ParseFile::getErrorMsg(), ParseFile::getKey(), MStructure::getModel(), MStructure::getName(), ParseFile::getNextLine(), StructTable::getNextStruct(), ParseFile::getPath(), MStructure::getRefModel(), getSearchPara(), ParseFile::getValue(), Species::id, StructTable::load(), loadData(), loadDB(), loadDBSelector(), loadModel(), m_CSpecies, m_Geom, m_GeomMutex, m_Sensors, m_SModel, SearcherParams::read(), Species::reset(), ParseFile::setParseError(), SensorCollection::updateModels(), and SearcherParams::write().

                                  {
    ParseFile is(bfile);
    if(is) {
        cout << "loading " << bfile << endl;
        string sbpath = is.getPath();
        m_CSpecies.reset();
        //try?
        while(is.getNextLine()) {
            string param = is.getKey();
            if(param == "db") {
                if(!loadDB((sbpath+is.getValue()).c_str())) {
                    cerr << "Couldn't load data base " << is.getValue()<< endl;
                    return false;
                }
            } else if(param == "dbsel") {
                if(!loadDBSelector((sbpath+is.getValue()).c_str())) {
                    cerr<<"Couldn't load data base selector "
                        <<is.getValue()<<endl;
                    return false;
                }
            } else if(param == "data") {
                if(!loadData((sbpath+is.getValue()).c_str())) {
                    cerr << "Couldn't load data set " <<is.getValue()<< endl;
                    return false;
                }
            } else if(param == "model") {
                cout << "loading model " << is.getValue() << endl;
                if(!loadModel((sbpath+is.getValue()).c_str())) {
                    cerr << "Couldn't load model file " <<is.getValue()<< endl;
                    return false;
                }
            } else if(param == "structure") {
                cout << "loading structure " << is.getValue() << endl;
                vuLock glock(m_GeomMutex);
                if(!m_SModel.load((sbpath+is.getValue()).c_str())) {
                    cerr << "Couldn't load structure description "
                         << (sbpath+is.getValue()) << endl;
                    return false;
                }
                cout << m_SModel << endl;
//                 list<Model*> ml;
//                 if(getAllModels( back_inserter( ml ) )) {
//                     for(list<Model*>::iterator gi=ml.begin();
//                         gi != ml.end(); gi++)
//                         (*gi)->reattachSensors();
//                 }
//                 m_Search.reattachSensors();
                m_Sensors.updateModels();
            } else if(param == "searcher") {
                cout << "configuring searcher from " << is.getValue() << endl;
                ParseFile pf((sbpath+is.getValue()).c_str());
                if(!getSearchPara().read(pf)) {
                    cerr << "Couldn't searcher config "<<is.getValue()<< endl;
                    return false;
                }
                getSearchPara().write(cout);
            } else if(param.size()>0) {
                is.setParseError("Error parsing brain description.");
                cerr << is.getErrorMsg() << endl;
                return false;
            }
        } // of while getline
        if(!(*m_Geom)) {
            MStructure& cs = m_SModel.getNextStruct();
            if(cs) cout << "current structure is: " << cs.getName() << endl;
            if(!cs.getRefModel(m_CSpecies.id, *m_Geom))
                *m_Geom = cs.getModel();
        }
        cout << "finished loading " << bfile << endl;
    } else {
        cerr << "Could not open " << bfile << endl;
        return false;
    }
    return true;
}

bool Brain::loadData	(	const char *	filename,
		dword	ppmm = 0
	)

Definition at line 288 of file Brain.cpp.

References attachBrowseData(), Species::getScale(), m_BrowseData, m_CSpecies, m_Data, m_DataMutex, and m_ImmediateData.

Referenced by load(), and loadSpecies().

{
    vuLock dlock(m_DataMutex);
    if(!ppmm) ppmm = m_CSpecies.getScale();
    bool ret = m_BrowseData->load(filename, ppmm);
    if(ret) {
        if(m_ImmediateData) attachBrowseData();
        else if(m_Data->initialized()) m_Data->clear();
    }
    return ret;
}

bool Brain::loadDB

(

const char *

filename

)

Definition at line 195 of file Brain.cpp.

References DBSelector::getCurSpecies(), SpeciesDB::load(), loadSpecies(), m_DB, m_DBSelector, and DBSelector::update().

Referenced by load().

{
    if(!m_DB.load(filename)) return false;
    m_DBSelector.update();
    loadSpecies(m_DBSelector.getCurSpecies());
    return true;
}

bool Brain::loadDBSelector

(

const char *

filename

)

Definition at line 203 of file Brain.cpp.

References DBSelector::getCurSpecies(), DBSelector::load(), loadSpecies(), and m_DBSelector.

Referenced by load().

{
    if(!m_DBSelector.load(filename)) return false;
    loadSpecies(m_DBSelector.getCurSpecies());
    return true;
}

bool Brain::loadModel

(

const char *

filename

)

Definition at line 163 of file Brain.cpp.

References m_Geom, m_GeomMutex, m_Sensors, Model::readFile(), setupSearch(), and SensorCollection::updateModels().

Referenced by load(), and triggerTest().

{
    vuLock glock(m_GeomMutex);
    //Model *model = new Model(&m_Data, &m_Sensors);
    bool ret=m_Geom->readFile(filename);
    //changeModel(model->getName());
    //m_CStates->push_back(model);
    //m_Geom = model;
    //m_CurState = m_CStates->size()-1;
//     if(ret) {
//         m_Prototypes[m_Geom->getName()] = new Model(*m_Geom);
//         //remove initial dummy model
//         string dmn = Model().getName();
//         if(m_Instances.count(dmn)) {
//             for(vector<Model*>::iterator mi=m_Instances[dmn].begin();
//                 mi != m_Instances[dmn].end(); mi++)
//                 delete *mi;
//             m_Instances.erase(dmn);
//         }
//     }
//     list<Model*> ml;
//     if(getAllModels( back_inserter( ml ) )) {
//         for(list<Model*>::iterator gi=ml.begin(); gi != ml.end(); gi++)
//             if(*gi != m_Geom) (*gi)->reattachSensors();
//     }
//     m_SModel.reattachSensors();
//     m_Search.reattachSensors();
    m_Sensors.updateModels();
    setupSearch();
    return true;
}

bool Brain::loadSpecies

(

const Species &

spec

)

Definition at line 210 of file Brain.cpp.

References SpeciesDB::getDirectory(), Species::getFlagString(), Species::getScale(), loadData(), m_CSpecies, m_DB, setStatusText(), and setTitle().

Referenced by doCommand(), loadDB(), loadDBSelector(), run(), and triggerTest().

{
    m_CSpecies = spec;
    map<string,string>::const_iterator in = spec.find("image");
    if(in == spec.end()) return false;

    string msg = "species_id: ";
    stringstream sstrm;
    sstrm << m_CSpecies.getScale();
    string number;
    sstrm >> number;
    msg += m_CSpecies["species_id"] + "  image: " + m_CSpecies["image"]
        + " flags: " + m_CSpecies.getFlagString()
        + " scale (pixels per mm): "+number;
    setStatusText(msg.c_str());
    setTitle(m_CSpecies["name"].c_str());

    return loadData((m_DB.getDirectory()+"/"+in->second).c_str(),
                    spec.getScale());
}

bool Brain::mergeInstances

(

)

create a new instance 'all' containing copies of all instances.

Definition at line 261 of file Brain.cpp.

References changeModel(), m_CStates, m_Instances, MERGENAME, and switchState().

Referenced by getSensors().

{
    return false;
    static const string mergename(MERGENAME);
    if(m_Instances.size() <= 1) return false;
    if(changeModel(mergename)) {
        for(vector<Model*>::iterator mi=m_CStates->begin();
            mi!=m_CStates->end(); mi++)
            delete *mi;
    }
    int msize=0;
    for(map<string, vector<Model*> >::iterator ii = m_Instances.begin();
        ii != m_Instances.end(); ii++)
        msize+=ii->second.size();
    m_CStates->reserve(msize);
    for(map<string, vector<Model*> >::iterator ii = m_Instances.begin();
        ii != m_Instances.end(); ii++)
    {
        if(ii->first != mergename)
            for(vector<Model*>::iterator mi=ii->second.begin();
                mi!=ii->second.end(); mi++)
                m_CStates->push_back(new Model(**mi));
    }
    switchState(0);
    return true;
}

void Brain::run ( int  whatsup, void *  data  )

virtual

virtual from vuThread

Implements vuThread.

Definition at line 334 of file Brain.cpp.

References attachBrowseData(), CHECK_THREAD, DO_ANALYSIS, DO_ANIMATE, DO_NOTHING, evolve(), EXIT_THREAD, StructTable::getBestInterpretation(), DBSelector::getCurSpecies(), StructTable::getIPaths(), getMilliSeconds(), StructTable::getNextStruct(), Species::hasFlag(), Species::id, loadSpecies(), vuMutex::lock(), m_CSpecies, m_CStates, m_Data, m_DataMutex, m_DBSelector, m_GeomMutex, m_RunMutex, m_SModel, m_ThreadActive, m_TimeScale, m_TimeStep, m_UpdateAllModels, DBSelector::nextSelection(), nowticks, StructTable::searchDone(), Species::SEL5, StructTable::startSearch(), vuMutex::unlock(), and vuThread::usleep().

{
    unsigned long lastticks = 0;
    static int anastate = 0;
    switch(whatsup) {
    case DO_ANIMATE:
        if(m_ThreadActive[DO_ANIMATE]) break;
        m_ThreadActive[DO_ANIMATE] = true;
        while(m_RunMutex[DO_ANIMATE].trylock()) {
            double dt;
            unsigned long nowticks = getMilliSeconds();
            if(!lastticks) {
                lastticks = nowticks;
                dt = 0.0;
            } else {
                dt = (nowticks-lastticks)*0.001; //seconds
            }
            if(dt>m_TimeStep) {
                vuLock glock(m_GeomMutex);
                vuLock dlock(m_DataMutex);
                if(dt>2*m_TimeStep) dt = m_TimeStep;
                lastticks=nowticks;
                if(m_Data->getDim1Size()) {
                    evolve(dt*m_TimeScale);
                }
                if(m_UpdateAllModels) {
                    for(vector<Model*>::iterator m = m_CStates->begin();
                        m!=m_CStates->end(); m++)
                    {
                        (*m)->updateParticles(dt*m_TimeScale);
                    }
                }
            }
            vuThread::usleep((dword)(1000*m_TimeStep));
            m_RunMutex[DO_ANIMATE].unlock();
        }
        m_ThreadActive[DO_ANIMATE] = false;
        m_RunMutex[DO_ANIMATE].unlock();
        break;
    case DO_NOTHING:
        if(m_ThreadActive[DO_NOTHING]) break;
        m_ThreadActive[DO_NOTHING] = true;
        while(m_RunMutex[DO_NOTHING].trylock()) {
            usleep((dword)(1000*m_TimeStep));
            m_RunMutex[DO_NOTHING].unlock();
        }
        m_ThreadActive[DO_NOTHING] = false;
        m_RunMutex[DO_NOTHING].unlock();
        break;
    case DO_ANALYSIS:
    {
        anastate = (int)(intptr_t)data;
        if(m_ThreadActive[DO_ANALYSIS]) break;
        m_ThreadActive[DO_ANALYSIS] = true;
        if(!m_RunMutex[DO_ANALYSIS].trylock()) {
            EXIT_THREAD(DO_ANALYSIS);
            break;
        } // now we have locked the runmutex
        MStructure& st = m_SModel.getNextStruct(0);
        if(m_DBSelector.nextSelection(-2)) {
            ofstream os("structmatch.txt",ios::app);
            os << "checking structural matches" << endl << endl;
            do{
                if(m_DBSelector.getCurSpecies().hasFlag(Species::SEL5)) {
                    m_GeomMutex.lock();
                    loadSpecies(m_DBSelector.getCurSpecies());
                    m_GeomMutex.unlock();
                    CHECK_THREAD(DO_ANALYSIS);
                    cout << "hello" << endl;
                    m_GeomMutex.lock();
                    attachBrowseData();
                    m_GeomMutex.unlock();
                    //do analysis here (anahere)
                    os << "species id: " << m_CSpecies.id
                       << "  name: " << m_CSpecies["name"] << endl;
                    unsigned long nowticks = getMilliSeconds();
                    m_SModel.startSearch();
                    while(!m_SModel.searchDone()) {
                        CHECK_THREAD(DO_ANALYSIS);  // sleep
                    }
                    const map<string,StructPath>& interp =
                        m_SModel.getIPaths();
                    os << "best interpretation: "
                       << m_SModel.getBestInterpretation() << endl;
                    for(map<string,StructPath>::const_iterator ip =
                            interp.begin(); ip != interp.end(); ip++)
                    {
                        os << ip->first << ": "
                           << ip->second.getRelGoodness() << endl;
                    }
                    os << "time: " << (getMilliSeconds()-nowticks)*0.001
                       << endl;
                    cout << "best interpretation: "
                         << m_SModel.getBestInterpretation() << endl;
                    //output results
                }
                if(anastate == -1) { EXIT_THREAD(DO_ANALYSIS); break; }
            } while(m_DBSelector.nextSelection(1,false));
        }
        EXIT_THREAD(DO_ANALYSIS);
        cout << "analysis terminated" << endl;
        break;
    }
    default:
        break;
    }
}

void Brain::setupSearch ( enum SearchWhat  what = SW_RESET, const PropVec &  prop = PropVec()  )

protected

Definition at line 1520 of file Brain.cpp.

References ExpectationMap::add(), ExpectationMap::correctLBUB(), DUMP, Searcher::getExpectationMap(), EMDRect::getLB(), getPropScale(), Model::getStdRadius(), EMDRect::getUB(), m_Data, m_Geom, M_PI, m_Search, Searcher::setExpectationMap(), EMDRect::setLB(), setPropDir(), setPropPos(), setPropScale(), ExpectationMap::setRepresentative(), EMDRect::setUB(), SW_LB, SW_RESET, SW_SET, SW_SPREAD, and SW_UB.

Referenced by attachBrowseData(), loadModel(), and triggerTest().

{
    ExpectationMap& cem = m_Search.getExpectationMap();
    //ExpectationMap::EDistList& cdl=cem.getDistList();
    if(what == SW_SET && cem) {
        cem.setRepresentative(*m_Geom);
    } else {
        ExpectationMap em(*m_Geom);
        PropVec propl(0.), propu(0.);
        if(what != SW_RESET && cem) {
            propu = cem.getUB();
            propl = cem.getLB();
        } else {
            Point2D dims((float)m_Data->getDim1Size(),
                         (float)m_Data->getDim2Size());
            float scale = m_Geom->getStdRadius();
            setPropPos(propu, dims);
            setPropDir(propu, 2*M_PI);
            setPropScale(propu, scale*2);
            setPropScale(propl, scale*0.5);
        }
        if(what == SW_UB) propu = prop;
        else if(what == SW_LB) propl = prop;
        else if(what == SW_SPREAD) {
            float radius = getPropScale(prop);
            PropVec plusminus;
            setPropPos(plusminus, Point2D(radius, radius));
            setPropScale(plusminus, getPropScale(prop)*0.2);
            setPropDir(plusminus, M_PI*0.2);
            propu = prop+plusminus;
            propl = prop-plusminus;
        }
        ExpectationMap::correctLBUB(propl, propu);
        em.setLB(propl);
        em.setUB(propu);
        em.add(new EMDRect(propl,propu));
        m_Search.setExpectationMap(em);
    }
    DUMP(m_Search.getExpectationMap().getLB());
    DUMP(m_Search.getExpectationMap().getUB());
}

bool Brain::switchState

(

dword

newstate

)

Definition at line 1255 of file Brain.cpp.

References m_CurState, and m_Geom.

Referenced by changeModel(), distributeModel(), evolve(), killState(), mergeInstances(), and triggerTest().

                                   {
    if(state < m_CStates->size()) {
        m_CurState = state;
        m_Geom = (*m_CStates)[state];
        return true;
    }else {
        m_CurState = 0;
        m_Geom = (*m_CStates)[0];
        return false;
    }
}

void Brain::toggleUpdateForAll ( bool  onoff = true )

inline

Definition at line 64 of file Brain.h.

References evolve(), findWinners(), and m_UpdateAllModels.

Referenced by triggerTest().

{ m_UpdateAllModels=onoff; }

bool Brain::triggerTest	(	int	mx,
		int	my,
		int	what = 0
	)

Definition at line 442 of file Brain.cpp.

References __SHAPEWEIGHT, dmutil::abs(), Model::adaptProportion(), Edge::adaptRestLength(), Model::adaptRestLength(), Model::adaptRestLengthSel(), Model::addEdge(), Model::addNode(), Model::addNoise(), SensorCollection::addSensor(), attachBrowseData(), Node::attachSensor(), Model::connectNodes(), Model::createEdgeSensors(), Node::disableState(), distributeModel(), doCommand(), DUMP, duplicateState(), Node::enableState(), StructTable::evalRelations(), Edge::from, Model::getCenter(), DBSelector::getCurSpecies(), Model::getDeformation(), Model::getEdge(), Model::getEdgeSensorFit(), StructTable::getFilename(), Model::getFilename(), Model::getFlags(), Species::getFlagString(), Model::getHLNode(), StructTable::getIPaths(), MStructure::getModel(), MStructure::getName(), Model::getName(), Model::getNEdges(), StructTable::getNextStruct(), Model::getNNodes(), Model::getNode(), Model::getProperties(), Model::getQualityOfFit(), getQualityRange(), MStructure::getRefModel(), MStructure::getRefModelIDs(), MStructure::getRefProp(), Searcher::getRepresentative(), MStructure::getSearcher(), Model::getSelectedNodesN(), SensorCollection::getSelectedSensor(), SensorCollection::getSensor(), Model::getSensorCollection(), Model::getSensorFit(), StructTable::getShownIP(), StructTable::getStructs(), Searcher::getWinners(), Species::id, ParticleParam::imgforce, killAllStates(), killCurrentState(), killState(), StructTable::load(), loadModel(), loadSpecies(), m_BrowseData, m_CSpecies, m_CStates, m_CurState, m_DataMutex, m_DBSelector, m_DesignMode, m_Done, m_DrawOwnState, m_Geom, m_GeomMutex, M_PI, m_Prototypes, m_Search, m_Sensors, m_SModel, m_TimeScale, Model::nearestNode(), DBSelector::nextSelection(), DBSelector::nextSelector(), Model::phys, Model::prepareTorque(), Model::reattachSensors(), Model::removeEdges(), Model::removeNode(), Edge::restlength, Model::rotate(), Model::scale(), Model::scaleSel(), Species::SEL5, Model::selMaskMat(), Species::setFlag(), Model::setHLNode(), MStructure::setModel(), Node::setPos(), MStructure::setRefModel(), MStructure::setRefProp(), Model::setShapeWeight(), StructTable::setShownIP(), setStatusText(), setupSearch(), StructTable::showNextIP(), Edge::springconstant, Node::ST_SELECT, SW_LB, SW_SET, SW_SPREAD, SW_UB, switchState(), Edge::to, toggleUpdateForAll(), toString(), TRACE, Model::translate(), Searcher::triggerTest(), StructTable::triggerTest(), Species::unsetFlag(), SensorCollection::updateModels(), and Model::writeFile().

Referenced by getModel().

                                                {
    static int keymode=0;
    static int curpid=-1;
    static string command;
    static list<vector<float> > colors;
    switch(keymode) {
    case 1:
    {
        vuLock glock(m_GeomMutex);
        keymode = 0;
        return m_Search.triggerTest(mx, my, what);
    }
    break;
    case 2:
        if(what == KEY_Return) {
            cout << "command: " << command << endl;
            command = "";
            keymode = 1;
        } else {
            command += char(what);
            cout << char(what) << flush;
        }
        return true;
        break;
    case 3:
    {
        vuLock glock(m_GeomMutex);
        keymode = 0;
        bool ret = m_SModel.triggerTest(mx, my, what);
        return ret;
    }
    break;
    }
    switch(what) {
    case KEY_X:
        cout << "type command: " << flush;
        keymode = 2;
        break;
    case KEY_h:
        if(keymode) {
            if(keymode == 128) {
                dword cnt = 0;
                ofstream os("antcol.dat",ios::app);
                for(list< vector<float> >::const_iterator col=
                        colors.begin(); col != colors.end(); col++, cnt++)
                {
                    for(vector<float>::const_iterator c=col->begin();
                        c!=col->end(); c++)
                        os << *c << " ";
                    os << endl;
                }
                os << endl;
                cout << "wrote " << cnt << " colors to antcol.dat" << endl;
            }
            keymode = 0;
            colors.clear();
        } else keymode = 128;
        break;
    case KEY_j:
        if(keymode) {
            if(keymode == 129) {
                ofstream os("antbg.dat",ios::app);
                dword cnt=0;
                for(list< vector<float> >::const_iterator col=
                        colors.begin(); col != colors.end(); col++, cnt++)
                {
                    for(vector<float>::const_iterator c=col->begin();
                        c!=col->end(); c++)
                        os << *c << " ";
                    os << endl;
                }
                os << endl;
                cout << "wrote " << cnt << " colors to antbg.dat" << endl;
            }
            keymode = 0;
            colors.clear();
        } else keymode = 129;
    case KEY_H: //mouse move
        if(keymode == 128 || keymode == 129) {
            vuLock dlock(m_DataMutex);
            vector<float> col(m_BrowseData->getMValue(mx,my));
            for(vector<float>::const_iterator c=col.begin();
                c!=col.end(); c++)
                cout << " " << *c;
            cout << endl;
            colors.push_back(col);
        }
        if(m_DesignMode) {
            vuLock glock(m_GeomMutex);
            int HLNode = m_Geom->nearestNode(Point(mx,my));
            m_Geom->setHLNode(HLNode);
            setStatusText(string("node id: ") + toString(HLNode+1));
        } else m_Geom->setHLNode(-1);
        break;
    case KEY_Control_L: //mouse click
        if(!m_DesignMode) {
            vuLock glock(m_GeomMutex);
            m_Geom->translate(Point(mx,my)-m_Geom->getCenter());
        } else {
            vuLock glock(m_GeomMutex);
            if(m_Geom->getHLNode() >= 0) {
                m_Geom->getNode(m_Geom->getHLNode()).
                    toggleState(Node::ST_SELECT);
            }
#if 0
            cout<<"adding edge ["<<curpid+1
                <<" "<<cnid+1<<"]"<<endl;
            m_Geom->addEdge(curpid,cnid);
            m_Geom->prepareTorque();
#endif
        }
        break;
    case KEY_Return:
    {
        vuLock dlock(m_DataMutex);
        attachBrowseData();
    }
    break;
    case KEY_r: // r
    {
        //TRACE(m_Geom->getStdRadius());
        m_Geom->addNoise(m_Geom->phys.imgforce*0.05);
        break;
    }
    case KEY_d: // d
    {
        keymode = 3;
        cout << "smodel key: " << endl;
//          vuLock glock(m_GeomMutex);
//          duplicateState();
//          TRACE(m_CStates->size() << " models");
    }
    break;
    case KEY_space: // space
    {
        static bool ison = true;
        ison = !ison;
        toggleUpdateForAll(ison);
    }
    break;
    case KEY_s: // s
    {
        keymode = 1;
        cout << "searcher key: " << endl;
        break;
    }
    break;
    case KEY_S: //S
        m_DrawOwnState = !m_DrawOwnState;
        break;
    case KEY_q:
        setupSearch(SW_UB, m_Geom->getProperties());
        break;
    case KEY_a:
        setupSearch(SW_LB, m_Geom->getProperties());
        break;
    case KEY_A:
        setupSearch(SW_SPREAD, m_Geom->getProperties());
        break;
    case KEY_z:
        setupSearch(SW_SET);
        break;
    case KEY_Z:
        setupSearch();
        break;
    case KEY_W:
    {
        vuLock glock((vuMutex&)m_GeomMutex);
        *m_Geom = m_Search.getRepresentative();
        break;
    }
    case KEY_Right: //right
    {
        vuLock glock(m_GeomMutex);
        switchState((m_CurState+1)%m_CStates->size());
        cout << "quality of fit "<<(m_Geom->getQualityOfFit()) << endl;
        cout << " flags: " << hex << m_Geom->getFlags() << endl << dec;
    }
    break;
    case KEY_Left: //left
    {
        vuLock glock(m_GeomMutex);
        switchState((int(m_CurState)-1)%m_CStates->size());
        cout << "quality of fit "<<(m_Geom->getQualityOfFit()) << endl;
        cout << " flags: " << hex << m_Geom->getFlags() << endl << dec;
    }
    break;
    case KEY_l: //l
        if(m_Geom->getSelectedNodesN()) {
            m_Geom->adaptRestLengthSel(0.2, m_Geom->selMaskMat());
        } else m_Geom->adaptRestLength(0.2);
        break;
    case KEY_L:
    {
        vuLock glock(m_GeomMutex);
        m_SModel.load(m_SModel.getFilename());
        break;
    }
    case KEY_k: //k
        killCurrentState();
        break;
    case KEY_p: //p
        m_Geom->adaptProportion(0.3);
        break;
    case KEY_D: //D
    {
        vuLock glock(m_GeomMutex);
        float lqof,hqof;
        getQualityRange(lqof,hqof,__SHAPEWEIGHT);
        float qth = hqof*0.7;
        TRACE("quality th " <<qth);
#if 1
//#ifndef DISTRIBUTE_ALL_PROTOTYPES
//            Model *pt = m_Prototypes[m_CurPrototype];
        Model *pt = m_Geom;
        cout << "distributing " << pt->getName() << endl;
        pt->setShapeWeight(__SHAPEWEIGHT);
        int nm=0, ni=100;
        while(nm<50 && --ni)
            nm+=distributeModel(*pt,0,qth,true);
#else
        for(map<string,Model*>::iterator gi=m_Prototypes.begin();
            gi!=m_Prototypes.end(); gi++)
        {
            cout << "distributing " << gi->second->getName() << endl;
            gi->second->setShapeWeight(__SHAPEWEIGHT);
            int nm=0, ni=100;
            while(nm<50 && --ni)
                nm+=distributeModel(*gi->second,0,qth,true);
        }
#endif
        TRACE(m_CStates->size() << " models");
    }
    break;
    case KEY_R: //R
    {
        vuLock glock(m_GeomMutex);
        m_SModel.evalRelations();
//                  for(vector<Model*>::iterator m=m_CStates->begin();
//                      m!=m_CStates->end(); m++) {
//                      (*m)->addNoise(0.05);
//                         (*m)->setWinner(false);
//                     }
    }
    break;
    case KEY_K: //K
    {
        vuLock glock(m_GeomMutex);
        killAllStates();
    }
    break;
    case KEY_g: //g
    {
        MStructure& cs = m_SModel.getNextStruct(0);
        loadModel(cs.getModel().getFilename().c_str()); //"shape.dm"
        cs.setModel(*m_Geom);
    }
    break;
    case KEY_G: //G
    {
        MStructure& cs = m_SModel.getNextStruct(0);
        m_Geom->writeFile(cs.getModel().getFilename().c_str());
        break;
    }
    case KEY_v: //v
    {
        vuLock glock(m_GeomMutex);
        Node n((float)mx,(float)my);
        bool doubleclick=false;
        if(m_Geom->getNNodes()>0) {
            Node &ln = m_Geom->getNode(m_Geom->getNNodes()-1);
            doubleclick = ((n-ln).norm()<2);
        }
        if(doubleclick) {
            //cout << "doubleclick"<<endl;
            int lnid = m_Geom->getNNodes()-1;
            if(lnid>0) {
                m_Geom->addEdge(lnid-1,lnid);
                m_Geom->prepareTorque();
            }
        } else {
            n.attachSensor(m_Sensors.getSensor("S0"));
            m_Geom->setHLNode(m_Geom->addNode(n));
        }
    }
    break;
    case KEY_V: //V
    {
        vuLock glock(m_GeomMutex);
        m_Geom->removeNode(m_Geom->getHLNode());
    }
    break;
    case KEY_u:
    {
        m_DBSelector.getCurSpecies().setFlag(Species::SEL5);
        cout << m_DBSelector.getCurSpecies().getFlagString() << endl;
        break;
    }
    case KEY_U:
    {
//             //one update step
//          vuLock glock(m_GeomMutex);
//          for(vector<Model*>::iterator m = m_CStates->begin();
//              m!=m_CStates->end(); m++)
//          {
//              (*m)->updateParticles(m_TimeStep);
//          }
        m_DBSelector.getCurSpecies().unsetFlag(Species::SEL5);
        cout << m_DBSelector.getCurSpecies().getFlagString() << endl;
        break;
    }
    case KEY_1: //1
        //m_Geom->pushRotate(m_Geom->getCenter(), 1);
        m_Geom->rotate(M_PI*0.03);
        break;
    case KEY_2: //2
        //m_Geom->pushRotate(m_Geom->getCenter(), -1);
        m_Geom->rotate(-M_PI*0.03);
        break;
    case KEY_3:
        if(m_Geom->getSelectedNodesN()) {
            m_Geom->scaleSel(0.95, m_Geom->selMaskMat());
        } else m_Geom->scale(0.95, true);
        break;
    case KEY_4:
        if(m_Geom->getSelectedNodesN()) {
            m_Geom->scaleSel(1.05, m_Geom->selMaskMat());
        } else m_Geom->scale(1.05, true);
        break;
    case KEY_5: //5
        if(m_Geom->getHLNode()>=0) {
            m_Geom->getNode(m_Geom->getHLNode()).setPos(Point2D(mx,my));
            for(int e=0; e<m_Geom->getNEdges(); e++) {
                Edge& ed = m_Geom->getEdge(e);
                if(ed.from == m_Geom->getHLNode() ||
                   ed.to == m_Geom->getHLNode()) ed.adaptRestLength();
            }
        }
        break;
    case KEY_6:
    {
        vuLock glock(m_GeomMutex);
        sensor_ptr s = m_Sensors[m_Sensors.getSelectedSensor()];
        m_Geom->getNode(m_Geom->getHLNode()).attachSensor(s);
        break;
    }
    case KEY_7:
    {
        vuLock glock(m_GeomMutex);
        sensor_ptr zs = std::make_shared<ZeroSensor>();
        zs = m_Geom->getSensorCollection()->addSensor("zero", zs);
        Node n; n.setPos(m_Geom->getNode(5));
        //n.mass *= 0.1;
        n.attachSensor(zs);
        int nid = m_Geom->addNode(n);
        int eid = m_Geom->addEdge(18, nid);
        m_Geom->getEdge(eid).springconstant *= 1;
        m_Geom->getEdge(eid).restlength *= 1.5;
        m_Geom->getEdge(m_Geom->addEdge(4, nid)).springconstant *= 1;
        m_Geom->getEdge(m_Geom->addEdge(6, nid)).springconstant *= 1;
        m_Geom->prepareTorque();
        break;
    }
    case KEY_8:
    {
        vuLock glock(m_GeomMutex);
        MStructure& st = m_SModel.getNextStruct(0);
        (Searcher&)st.getSearcher() = m_Search;
        break;
    }
    case KEY_9:
    {
        vuLock glock(m_GeomMutex);
        MStructure& st = m_SModel.getNextStruct(0);
        m_Search = st.getSearcher();
        break;
    }
    case KEY_F1: //F1
        m_TimeScale*=2;
        setStatusText(string("current time scale is ")
                      +toString(m_TimeScale));
        break;
    case KEY_F2: //F2
        m_TimeScale*=0.5;
        setStatusText(string("current time scale is ")
                      +toString(m_TimeScale));
        break;
    case KEY_F3: //F3
        m_Done = !m_Done;
        break;
    case KEY_F4: //F4
    {
        vuLock glock(m_GeomMutex);
// determine range of qualities
        float lqof,hqof;
        getQualityRange(lqof,hqof,__SHAPEWEIGHT);
// remove bad ones
        float kill_quality_th = 0.05;
        float relq = (hqof-lqof)*kill_quality_th+lqof;
        //(hqof!=0.0) ? (m->getQualityOfFit()-lqof)/hqof :1;
        for(int mi=0; mi<(int)m_CStates->size()
                && (int)m_CStates->size()>1;)
        {
            Model *m = (*m_CStates)[mi];
            if(relq > m->getQualityOfFit()) {
                //TRACE(relq);
                killState(mi);
            }else mi++;
        }
        break;
    }
    case KEY_P:
    {
        Point mouse(mx,my);
        int mind=0; float md=1000000;
        int cind = 0;
        for(vector<Model*>::iterator m = m_CStates->begin();
            m!=m_CStates->end(); m++,cind++)
        {
            float d = ((*m)->getCenter()-mouse).norm2();
            if(!cind) md = d;
            else if(d<md) {
                md = d;
                mind = cind;
            }
        }
        vuLock glock(m_GeomMutex);
        switchState(mind);
        cout << "quality of fit "<<(m_Geom->getQualityOfFit()) << endl;
        register float lv = m_Geom->getDeformation();
        cout << "deformation: " << lv << " mapped: "<<exp(-5*abs(lv))<<endl;
        cout << "sensors: "<< m_Geom->getSensorFit() << endl;
        dword nes = 0;
        cout << "edges: "<< m_Geom->getEdgeSensorFit(&nes) << endl;
        cout << "   nedgesensors: " << nes << endl;
        cout << " flags: " << hex << m_Geom->getFlags() << endl;
        break;
    }
    case KEY_0: //0
    {
        vuLock glock(m_GeomMutex);
// determine range of qualities (in terms of shape)
        float lqof,hqof,aqof;
        lqof=1;
        hqof=0;
        aqof=0;
        for(vector<Model*>::const_iterator m = m_CStates->begin();
            m!=m_CStates->end(); m++)
        {
            float lv = (*m)->getDeformation()*10;
            lv = exp(-lv*lv);
            if(lv>hqof) hqof=lv;
            if(lv<lqof) lqof=lv;
            aqof+=lv;
        }
        aqof /= m_CStates->size();
// remove bad ones
        //float kill_quality_th = 0.03;
        for(int mi=0; mi<(int)m_CStates->size()
                && (int)m_CStates->size()>1;)
        {
            Model *m = (*m_CStates)[mi];
            float lv = m->getDeformation()*10;
            lv = exp(-lv*lv);
            float relq = (hqof!=0.0) ? (lv-lqof)/hqof :1;
            //if(relq < kill_quality_th && !m->isWinner()) {
            if(lv < aqof && !m->isWinner()) {
                TRACE(relq);
                killState(mi);
            }else mi++;
        }
        break;
    }
    case KEY_w: //w
    {
        list<const Model*> winners;
        m_Search.getWinners( back_inserter( winners ) );
        if(!winners.empty()) {
            vuLock glock(m_GeomMutex);
            m_CStates->clear();
            for(list<const Model*>::iterator wpi = winners.begin();
                wpi != winners.end(); wpi++)
                duplicateState(*wpi);
            switchState(0);
            cout << "copied " << winners.size() << " winners" << endl;
        }
        break;
    }
    case KEY_t:
    {
        vuLock glock(m_GeomMutex);
        dword nesensors = m_Geom->createEdgeSensors(0.15);
        cout << "created " << nesensors << " edge sensors" << endl;
        break;
    }
    case KEY_e:
    { vuLock glock(m_GeomMutex); m_Geom->connectNodes(); break; }
    case KEY_E:
    { vuLock glock(m_GeomMutex); m_Geom->removeEdges(); break; }
    case KEY_n:
    {
        for(int i = 0; i<m_Geom->getNNodes(); i++)
            m_Geom->getNode(i).disableState(Node::ST_SELECT);
        break;
    }
    case KEY_N:
    {
        for(int i = 0; i<m_Geom->getNNodes(); i++)
            m_Geom->getNode(i).enableState(Node::ST_SELECT);
        break;
    }
    case KEY_c:
    {
        vuLock glock(m_GeomMutex);
        Node n((float)mx,(float)my);
        bool doubleclick=false;
        if(m_Geom->getNNodes()>0) {
            Node &ln = m_Geom->getNode(m_Geom->getNNodes()-1);
            doubleclick = ((n-ln).norm()<2);
        }
        if(doubleclick) {
            //cout << "doubleclick"<<endl;
            int lnid = m_Geom->getNNodes()-1;
            if(lnid>0) {
                m_Geom->addEdge(lnid-1,lnid);
                m_Geom->prepareTorque();
            }
        } else {
            n.attachSensor(m_Sensors.getSensor("S0"));
            m_Geom->setHLNode(m_Geom->addNode(n));
        }
        break;
    }
/*
  case KEY_o: // postscript output
  {
  string fname = "graph.ps";
  CAMgraphicsProcess  Gprocess; // declare a graphics process
  // declare a PostScript driver
  CAMpostScriptDriver Pdriver(fname.c_str());
  Gprocess.attachDriver(Pdriver); // Attach driver to process

  Gprocess.setAxisRange(0,m_BrowseData->getDim1Size(),0,
  m_BrowseData->getDim2Size());
  Gprocess.title("Deformable model"); // label the plot
  Gprocess.labelX(" X ");
  Gprocess.labelY(" Y ");
  m_Geom->drawPS(Gprocess);
  //Gprocess.plot(x,y,n);                       // do the plotting
  Gprocess.frame();                           // "frame" the plot

  Gprocess.detachDriver();                    // detach the driver
  cout << "wrote file " << fname << endl;
  break;
  }
*/
    case KEY_period: //.
        m_DesignMode = !m_DesignMode;
//            *m_Prototypes[m_Geom->getName()] = *m_Geom;
        break;
    case KEY_Page_Up://pgup
    {
        m_DBSelector.nextSelection(-1);
        loadSpecies(m_DBSelector.getCurSpecies());
        break;
    }
    case KEY_Page_Down://pgdn
    {
        m_DBSelector.nextSelection(1);
        loadSpecies(m_DBSelector.getCurSpecies());
        break;
    }
    case KEY_Home://home
    {
        m_DBSelector.nextSelector(-1, true, 4);
        loadSpecies(m_DBSelector.getCurSpecies());
        break;
    }
    case KEY_End://end
    {
        m_DBSelector.nextSelector(1, true, 4);
        loadSpecies(m_DBSelector.getCurSpecies());
        break;
    }
    case KEY_Insert:
    {
        cout << m_DBSelector.getCurSpecies();
        cout << "image resolution is " << m_BrowseData->getDim1Size()
             << ", " << m_BrowseData->getDim2Size() << endl;
        break;
    }
    case KEY_Escape:
    {
        cout << "current flags <"
             << m_DBSelector.getCurSpecies().getFlagString()
             << "> change to (type 'savedb' to save DB): ";
        string cmdline;
        getline(cin, cmdline);
        dword split = cmdline.find(' ');
        string command = cmdline.substr(0,split);
        string value;
        if(split != cmdline.npos) value = cmdline.substr(split+1);
        cout << "command <" << command << "> value <"<<value<<">"<< endl;
        doCommand(command,value,mx,my);
        break;
    }
    case KEY_m:
    {
        vuLock glock((vuMutex&)m_GeomMutex);
#if 0
//scan through all reference models
        if(!m_SModel.getStructs().empty()) {
            list<dword> ids;
            MStructure& st = m_SModel.getNextStruct(0);
            cout << "scanning " << st.getName() << endl;
            cout << "nids: "
                 << st.getRefModelIDs( back_inserter(ids) ) << endl;
            for(list<dword>::iterator mid = ids.begin();
                mid != ids.end(); mid++) {
                cout << *mid << endl;
                Dataset d;
                Model m(&d);
                if(st.getRefModel(*mid, m))
                    cout << m.getProperties() << endl;
            }
        }
#else
        MStructure& st = m_SModel.getNextStruct(0);
        if(*m_Geom) {
            cout << "setting reference model for species id "
                 << m_CSpecies.id << endl;
            st.setRefModel(m_CSpecies.id, *m_Geom);
        } else {
            cout << "setting reference frame for species id "
                 << m_CSpecies.id << endl;
            PropVec frameprop(m_BrowseData->getPropVecMM());
            DUMP(frameprop);
            st.setRefProp(m_CSpecies.id, frameprop);
        }
#endif
        break;
    }
    case KEY_M:
    {
        vuLock glock((vuMutex&)m_GeomMutex);
        MStructure& st = m_SModel.getNextStruct(0);
        if(st.getRefModel(m_CSpecies.id, *m_Geom)) {
            cout << "found reference model!" << endl;
//                 list<Model*> ml;
//                 if(getAllModels( back_inserter( ml ) )) {
//                     for(list<Model*>::iterator gi=ml.begin();
//                         gi != ml.end(); gi++)
//                         (*gi)->reattachSensors();
//                 }
//                 m_Search.reattachSensors();
//                 m_SModel.reattachSensors();
            m_Sensors.updateModels();
            PropVec prop;
            if(st.getRefProp(m_CSpecies.id, prop))
                DUMP(prop);
        } else cout << "could not find reference model" << endl;
        break;
    }
    case KEY_comma:
    {
        vuLock glock((vuMutex&)m_GeomMutex);
        MStructure& cs = m_SModel.getNextStruct();
        if(cs) cout << "current structure is: " << cs.getName() << endl;
//            if(!cs.getRefModel(m_CSpecies.id, *m_Geom))
        *m_Geom = cs.getModel();
        m_Geom->reattachSensors();
        break;
    }
    case KEY_slash:
    {
//show next interpretation
        vuLock glock(m_GeomMutex);
        m_SModel.showNextIP();
        map<string,StructPath>::const_iterator cp =
            m_SModel.getIPaths().find(m_SModel.getShownIP());
        float qual = 0.f;
        if(cp != m_SModel.getIPaths().end())
            qual = cp->second.getRelGoodness();
        cout << "showing interpretation " << m_SModel.getShownIP()
             << " (" << qual << ")" << endl;
        break;
    }
    case KEY_backslash:
    {
//show best interpretation
        vuLock glock(m_GeomMutex);
        m_SModel.setShownIP(string());
        cout << "switching to best interpretation" << endl;
        map<string,StructPath>::const_iterator cp =
            m_SModel.getIPaths().find(m_SModel.getShownIP());
        float qual = 0.f;
        if(cp != m_SModel.getIPaths().end())
            qual = cp->second.getRelGoodness();
        cout << "showing interpretation " << m_SModel.getShownIP()
             << " (" << qual << ")" << endl;
        break;
    }
    default:
        return false;
    }
    return true;
}

Member Data Documentation

dataset_ptr Brain::m_BrowseData

protected

Definition at line 90 of file Brain.h.

Referenced by attachBrowseData(), Brain(), doCommand(), drawAllModels(), getData(), loadData(), and triggerTest().

Species Brain::m_CSpecies

protected

Definition at line 100 of file Brain.h.

Referenced by doCommand(), load(), loadData(), loadSpecies(), run(), and triggerTest().

std::vector<Model*>* Brain::m_CStates

protected

Definition at line 93 of file Brain.h.

Referenced by Brain(), changeModel(), drawAllModels(), duplicateState(), evolve(), getAllModels(), getQualityRange(), killAllStates(), killState(), mergeInstances(), run(), triggerTest(), and ~Brain().

std::string Brain::m_CurPrototype

protected

Definition at line 96 of file Brain.h.

Referenced by Brain(), and changeModel().

dword Brain::m_CurState

protected

Definition at line 97 of file Brain.h.

Referenced by Brain(), distributeModel(), duplicateState(), evolve(), killAllStates(), killCurrentState(), killState(), switchState(), and triggerTest().

dataset_ptr Brain::m_Data

protected

Definition at line 89 of file Brain.h.

Referenced by attachBrowseData(), Brain(), distributeModel(), drawAllModels(), evolve(), getSensorData(), loadData(), run(), and setupSearch().

vuMutex Brain::m_DataMutex

protected

Definition at line 104 of file Brain.h.

Referenced by drawAllModels(), loadData(), run(), and triggerTest().

SpeciesDB Brain::m_DB

protected

Definition at line 98 of file Brain.h.

Referenced by doCommand(), loadDB(), and loadSpecies().

DBSelector Brain::m_DBSelector

protected

Definition at line 99 of file Brain.h.

Referenced by doCommand(), loadDB(), loadDBSelector(), run(), and triggerTest().

bool Brain::m_DesignMode

protected

Definition at line 107 of file Brain.h.

Referenced by Brain(), drawAllModels(), and triggerTest().

bool Brain::m_Done

protected

Definition at line 106 of file Brain.h.

Referenced by Brain(), evolve(), isDone(), and triggerTest().

bool Brain::m_DrawOwnState

protected

Definition at line 109 of file Brain.h.

Referenced by drawAllModels(), and triggerTest().

Model* Brain::m_Geom

protected

Definition at line 92 of file Brain.h.

Referenced by Brain(), distributeModel(), doCommand(), drawAllModels(), duplicateState(), evolve(), getModel(), load(), loadModel(), setupSearch(), switchState(), and triggerTest().

vuMutex Brain::m_GeomMutex

protected

Definition at line 104 of file Brain.h.

Referenced by drawAllModels(), getGeomMutex(), load(), loadModel(), run(), triggerTest(), and ~Brain().

bool Brain::m_ImmediateData

protected

Definition at line 108 of file Brain.h.

Referenced by Brain(), and loadData().

std::map<std::string, std::vector<Model*> > Brain::m_Instances

protected

Definition at line 95 of file Brain.h.

Referenced by changeModel(), and mergeInstances().

std::map<std::string,Model*> Brain::m_Prototypes

protected

Definition at line 94 of file Brain.h.

Referenced by triggerTest().

vuMutex Brain::m_RunMutex[DO_LAST]

protected

Definition at line 104 of file Brain.h.

Referenced by run(), and ~Brain().

Searcher Brain::m_Search

protected

Definition at line 110 of file Brain.h.

Referenced by drawAllModels(), evolve(), setupSearch(), and triggerTest().

SensorCollection Brain::m_Sensors

protected

Definition at line 91 of file Brain.h.

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

StructTable Brain::m_SModel

protected

Definition at line 112 of file Brain.h.

Referenced by attachBrowseData(), doCommand(), drawAllModels(), evolve(), load(), run(), and triggerTest().

bool Brain::m_ThreadActive[DO_LAST]

protected

Definition at line 105 of file Brain.h.

Referenced by Brain(), run(), and ~Brain().

float Brain::m_TimeScale

protected

Definition at line 102 of file Brain.h.

Referenced by run(), and triggerTest().

float Brain::m_TimeStep

protected

Definition at line 101 of file Brain.h.

Referenced by run().

bool Brain::m_UpdateAllModels

protected

Definition at line 103 of file Brain.h.

Referenced by run(), and toggleUpdateForAll().

std::list<Model> Brain::m_Winners

protected

Definition at line 111 of file Brain.h.

---

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

• src/Brain.h
• src/Brain.cpp