CEBL  2.1
EEGTrainingData.cpp
Go to the documentation of this file.
1 #include "EEGTrainingData.hpp"
2 #include "cppR/cppR.hpp"
3 #include <sstream>
4 #include <exception>
5 
6 using namespace cppR;
7 using namespace ublas;
8 using namespace std;
9 //constructor
11 {
12  data.resize(0);
13  filtered = false;
14 }
15 
16 //destructor
18 {
19 }
20 
21 //reserves space for c classes and s sequences
22 void EEGTrainingData::reserve(unsigned int cls, unsigned int seq)
23 {
24  if(cls > data.size())
25  {
26  data.resize(cls);
27  }
28 
29  for(unsigned int c=0;c<data.size();c++)
30  if(seq > data.at(c).size())
31  {
32  data.at(c).resize(seq);
33  }
34 }
35 
36 //sets data at class c and sequence s
37 void EEGTrainingData::set(unsigned int cls, unsigned int seq, EEGData &new_data)
38 {
39  if(cls >= unsigned(numClasses()) || seq >= unsigned(numSequences(cls)))
40  {
41  reserve(cls+1,seq+1);
42  }
43  this->data[cls][seq] = new_data;
44 }
45 
46 //appends data at class c and sequence s
47 void EEGTrainingData::append(unsigned int cls,
48  unsigned int seq, EEGData &new_data)
49 {
50  if(cls >= unsigned(numClasses()) || seq >= unsigned(numSequences(cls)))
51  {
52  reserve(cls+1,seq+1);
53  this->set(cls,seq,new_data);
54  }
55  if(this->numSamples(cls,seq)==0)
56  {
57  this->set(cls,seq,new_data);
58  }
59  else
60  {
61  data.at(cls).at(seq).append(new_data);
62  }
63 }
64 //returns data at location
65 EEGData& EEGTrainingData::get(unsigned int cls, unsigned int seq)
66 {
67  return data[cls][seq];
68 }
69 
70 //returns data at location
71 const EEGData & EEGTrainingData::getConst(unsigned int c, unsigned int s) const
72 {
73  return data.at(c).at(s);
74 }
75 
76 //getters
77 ublas::matrix<double> EEGTrainingData::collapse() const
78 {
79  EEGData ret;
80  for(unsigned int c=0; c<data.size(); c++)
81  {
82  for(unsigned int s=0; s<data[c].size();s++)
83  {
84  ret.append(data[c][s]);
85  }
86  }
87  return ret;
88 }
89 
90 
91 ublas::vector<int> EEGTrainingData::getClassVector() const
92 {
93  ublas::vector<int> ret;
94  ret.resize(data.size() * data.at(0).size());
95  int count = 0;
96  for(unsigned int c=0; c<data.size(); c++)
97  {
98  for(unsigned int s=0; s<data.at(c).size(); s++)
99  {
100  ret[count++] = c;
101  }
102  }
103  return ret;
104 }
105 
106 std::vector<int> EEGTrainingData::getSequenceOrder() const
107 {
108  return sequence_order;
109 }
110 
111 ublas::vector<int> EEGTrainingData::getTargets() const
112 {
113  // this is likely not the fastest way to do this
114  // but it works fine for now
115 
116  // find total number of samples in all classes
117  unsigned size = 0;
118  // for each class
119  for (unsigned cls = 0; cls < data.size(); ++cls)
120  {
121  // for each sequence
122  for (unsigned seq = 0; seq < data[cls].size(); ++seq)
123  {
124  // tally samples
125  size += data[cls][seq].size2();
126  }
127  }
128 
129  // vector holding class labels for every sample
130  ublas::vector<int> targets(size);
131 
132  // current index into our target vector
133  unsigned samp_index = 0;
134 
135  // for each class
136  for (unsigned cls = 0; cls < data.size(); ++cls)
137  {
138  // for each sequence
139  for (unsigned seq = 0; seq < data[cls].size(); ++seq)
140  {
141  // for each sample
142  for (int samp = 0; samp < data[cls][seq].size2(); ++samp)
143  {
144  // set target value
145  targets[samp_index] = cls;
146  ++samp_index;
147  }
148  }
149  }
150 
151  return targets;
152 }
153 
155 {
156  return data.size();
157 }
158 
160 {
161  if(data.size() == 0)
162  return 0;
163  else
164  return data.at(0).size();
165 }
166 
167 int EEGTrainingData::numSequences(unsigned int cls) const
168 {
169  if(cls >= unsigned(numClasses()))
170  return 0;
171  else
172  return data.at(cls).size();
173 }
174 
175 int EEGTrainingData::samplesInClass(unsigned int cls) const
176 {
177  int num = 0;
178  for(unsigned int i=0; i < data.at(cls).size(); i++)
179  {
180  num += ublas::matrix<double>(data.at(cls).at(i)).size2();
181  }
182  return num;
183 }
184 
185 int EEGTrainingData::numSamples(unsigned int cls,unsigned int seq) const
186 {
187  return this->data.at(cls).at(seq).numSamples();
188 }
189 
191 {
192  int num = 0;
193  for(unsigned int i=0; i < data.size(); i++)
194  {
195  num += samplesInClass(i);
196  }
197  return num;
198 }
199 
201 {
202  if(data.size() == 0 || data.at(0).size() == 0)
203  return 0;
204  else
205  return data.at(0).at(0).size1();
206 }
207 
208 //*************************************************************/
209 // Info about data
210 
212 std::vector<string> EEGTrainingData::getClassLabels() const
213 {
214  return class_labels;
215 }
216 
218 std::vector<string> EEGTrainingData::getChannelNames() const
219 {
220  return channel_names;
221 }
222 
225 {
226  return filtered;
227 }
228 
230 void EEGTrainingData::setClassLabels(std::vector<string> labels)
231 {
232  this->class_labels = labels;
233 }
234 
236 void EEGTrainingData::setChannelNames(std::vector<string> names)
237 {
238  this->channel_names = names;
239 }
240 
242 void EEGTrainingData::setFiltered(bool filtered)
243 {
244  this->filtered = filtered;
245 }
246 
247 //*************************************************************/
248 
249 ostream & operator<<(ostream &os, const EEGTrainingData &d)
250 {
251  os << "EEG Training Data: " << d.numClasses() << " classes "
252  << d.numSequences() << " sequences, " << d.numSamples() << " samples total.";
253 
254  return os;
255 }