The Machine Perception Toolbox (MPT)

00158                                 {
00159                 m_modeSize = _modes;
00160                 m_modesSet = m_contData = 0;
00161                 m_suggModeMean.reserve(m_modeSize);
00162                 m_modes.reserve(m_modeSize);
00163 
00164 
00165         } // Constructor

00166                    {
00167                 m_dataList.clear(); 
00168                 m_modes.clear(); 
00169 }       // Destructor

00294         {
00295                 ofstream os;
00296                 os.open("c:\\timedata.out", ios::trunc);
00297                 os << "data size = " << m_dataList.size() << "; Threshold = " << m_currThresh << endl;
00298                 for(int i = 0; i < m_dataList.size(); i++) 
00299                         os << m_dataList[i].val << "\t";
00300                 for(int m = 0; m < m_modeSize; m++) {
00301                         os << "mode = " << m << endl;
00302                         os << "mean = " << m_modes[m].getMean() << "; varience = " << m_modes[m].getVarience() << "; size = " 
00303                            << m_modes[m].getSize() << endl;
00304 
00305                         m_modes[m].printData(os);
00306                 }
00307                 os << endl << endl;
00308                 os.close();
00309 
00310 
00311 
00312         }

00257                                                   {
00258                 int dataSize = m_dataList.size();
00259                 int i, m, trial = 0;
00260                 int notStable = 1;
00261                 std::vector < double > curModeMean;
00262                 curModeMean.reserve(m_modeSize);
00263                 std::vector < int > curModeSize;
00264                 curModeSize.reserve(m_modeSize);
00265                 while (notStable && trial < maxTrials) {
00266                         for (i = 0; i < dataSize; i++) {
00267                                 int closestMode = 0;
00268                                 double dist = 100000.0;
00269                                 for (m = 0; m < m_modeSize; m++) {
00270                                         double curDist = m_dataList[i].val - m_suggModeMean[m];
00271                                         if (fabs(curDist) < dist) {
00272                                                 dist = fabs(curDist);
00273                                                 closestMode = m;
00274                                                 curModeMean[m] += m_dataList[i].val;
00275                                                 curModeSize[m]++;
00276                                         }
00277                                 }
00278                                 m_dataList[i].mode = closestMode;
00279                         }
00280                         notStable = 0;
00281                         for (m = 0; m < m_modeSize; m++) {
00282                                 double curMean = m_suggModeMean[m];
00283                                 m_suggModeMean[m] = curModeMean[m]/curModeSize[m];
00284                                 if (m_suggModeMean[m] != curMean) notStable++;
00285                         }
00286                         trial++;
00287                 }
00288         }

00248                             {
00249                 int mode = m_dataList[0].mode;
00250                 int rtn = m_modes[mode].subData(m_dataList[0]);
00251                 m_dataList.erase(m_dataList.begin());
00252                 return rtn;
00253         }

00174         {
00175                 float lamda = 0.1f;
00176                 ActData data;
00177                 m_contData = curAct*lamda + (1-lamda)*m_contData;
00178                 data.val = m_contData;
00179                 static int curI = 0;
00180                 int curSize = m_dataList.size();
00181                 if (curSize > 2000) {
00182                         subVal();
00183                         m_dataList.erase(m_dataList.begin());
00184                         curSize--;
00185                 }
00186                 else m_dataList.push_back(data);
00187 
00188                 if (curSize > 150 && !m_modesSet){
00189                         setModes();
00190                         for(int m = 0; m < m_modeSize; m++) {
00191                                 ModeData curMode(m_dataList, m);
00192                                 m_modes[m] = curMode;
00193                         }
00194                         m_modesSet = 1;
00195                 }
00196 
00197                 else if (curI > 500) {
00198                         curI = 0;
00199                         setModes();
00200                         m_modes.clear();
00201                         m_modesSet = 0;
00202                         for(int m = 0; m < m_modeSize; m++) {
00203                                 ModeData curMode(m_dataList, m);
00204                                 m_modes[m] = curMode;
00205                         }
00206                         printData();
00207                         m_modesSet = 2;
00208                 }
00209                 else {
00210                         int closestMode = 0;
00211                         double dist = 100000.0;
00212                         for (int m = 0; m < m_modeSize; m++) {
00213                                 double curDist = data.val - m_suggModeMean[m];
00214                                 if (fabs(curDist) < dist) {
00215                                         dist = fabs(curDist);
00216                                         closestMode = m;
00217                                 }
00218                         }
00219                         data.mode = closestMode;
00220                         m_modes[data.mode].addData(data);
00221                 }
00222 
00223 
00224                 curI++;
00225                 //only works with 2 modes, change later
00226                 if (m_modes.size() > 1)
00227                         m_currThresh = min(m_modes[0].getMax(), m_modes[1].getMax()) - max(m_modes[0].getMin(), m_modes[1].getMin());
00228                 else
00229                         m_currThresh = 0.0;
00230                 return m_currThresh;
00231                 //return (find optimal position);
00232         }


Public Member Functions
	Cluster (int _modes=2)
double	UpdateCluster (double curAct)
	~Cluster ()
Private Member Functions
void	printData ()
void	setModes (int maxTrials=100)
int	subVal ()
Private Attributes
double	m_contData
double	m_currThresh
std::vector< ActData >	m_dataList
double	m_max
double	m_mean
double	m_min
std::vector< ModeData >	m_modes
int	m_modeSize
int	m_modesSet
std::vector< double >	m_suggModeMean

The Machine Perception Toolbox

Cluster Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation