GestureRecognitionToolkit  Version: 1.0 Revision: 04-03-15
The Gesture Recognition Toolkit (GRT) is a cross-platform, open-source, c++ machine learning library for real-time gesture recognition.
DoubleMovingAverageFilter.cpp
Go to the documentation of this file.
1 
31 
32 namespace GRT{
33 
34 //Register the DoubleMovingAverageFilter module with the PreProcessing base class
35 RegisterPreProcessingModule< DoubleMovingAverageFilter > DoubleMovingAverageFilter::registerModule("DoubleMovingAverageFilter");
36 
37 DoubleMovingAverageFilter::DoubleMovingAverageFilter(UINT filterSize,UINT numDimensions){
38  classType = "DoubleMovingAverageFilter";
39  preProcessingType = classType;
40  debugLog.setProceedingText("[DEBUG DoubleMovingAverageFilter]");
41  errorLog.setProceedingText("[ERROR DoubleMovingAverageFilter]");
42  warningLog.setProceedingText("[WARNING DoubleMovingAverageFilter]");
43  init(filterSize,numDimensions);
44 }
45 
47 
48  this->filterSize = rhs.filterSize;
49  this->filter1 = rhs.filter1;
50  this->filter2 = rhs.filter2;
51  classType = "DoubleMovingAverageFilter";
52  preProcessingType = classType;
53  debugLog.setProceedingText("[DEBUG DoubleMovingAverageFilter]");
54  errorLog.setProceedingText("[ERROR DoubleMovingAverageFilter]");
55  warningLog.setProceedingText("[WARNING DoubleMovingAverageFilter]");
56 
57  //Copy the base variables
59 }
60 
62 
63 }
64 
66  if(this!=&rhs){
67  this->filterSize = rhs.filterSize;
68  this->filter1 = rhs.filter1;
69  this->filter2 = rhs.filter2;
70 
71  //Copy the base variables
73  }
74  return *this;
75 }
76 
78 
79  if( preProcessing == NULL ) return false;
80 
81  if( this->getPreProcessingType() == preProcessing->getPreProcessingType() ){
82 
84 
85  //Clone the classLabelTimeoutFilter values
86  this->filterSize = ptr->filterSize;
87  this->filter1 = ptr->filter1;
88  this->filter2 = ptr->filter2;
89 
90  //Clone the preprocessing base variables
91  return copyBaseVariables( preProcessing );
92  }
93 
94  errorLog << "clone(const PreProcessing *preProcessing) - PreProcessing Types Do Not Match!" << endl;
95 
96  return false;
97 }
98 
99 
100 bool DoubleMovingAverageFilter::process(const VectorDouble &inputVector){
101 
102  if( !initialized ){
103  errorLog << "process(const VectorDouble &inputVector) - The filter has not been initialized!" << endl;
104  return false;
105  }
106 
107  if( inputVector.size() != numInputDimensions ){
108  errorLog << "process(const VectorDouble &inputVector) - The size of the inputVector (" << inputVector.size() << ") does not match that of the filter (" << numInputDimensions << ")!" << endl;
109  return false;
110  }
111 
112  processedData = filter( inputVector );
113 
114  if( processedData.size() == numOutputDimensions ) return true;
115  return false;
116 }
117 
119  if( initialized ) return init(filterSize,numInputDimensions);
120  return false;
121 }
122 
123 bool DoubleMovingAverageFilter::saveModelToFile(string filename) const{
124 
125  if( !initialized ){
126  errorLog << "saveModelToFile(string filename) - The DoubleMovingAverageFilter has not been initialized" << endl;
127  return false;
128  }
129 
130  std::fstream file;
131  file.open(filename.c_str(), std::ios::out);
132 
133  if( !saveModelToFile( file ) ){
134  file.close();
135  return false;
136  }
137 
138  file.close();
139 
140  return true;
141 }
142 
144 
145  if( !file.is_open() ){
146  errorLog << "saveModelToFile(fstream &file) - The file is not open!" << endl;
147  return false;
148  }
149 
150  file << "GRT_DOUBLE_MOVING_AVERAGE_FILTER_FILE_V1.0" << endl;
151 
152  file << "NumInputDimensions: " << numInputDimensions << endl;
153  file << "NumOutputDimensions: " << numOutputDimensions << endl;
154  file << "FilterSize: " << filterSize << endl;
155 
156  return true;
157 }
158 
160 
161  std::fstream file;
162  file.open(filename.c_str(), std::ios::in);
163 
164  if( !loadModelFromFile( file ) ){
165  file.close();
166  initialized = false;
167  return false;
168  }
169 
170  file.close();
171 
172  return true;
173 }
174 
176 
177  if( !file.is_open() ){
178  errorLog << "loadModelFromFile(fstream &file) - The file is not open!" << endl;
179  return false;
180  }
181 
182  string word;
183 
184  //Load the header
185  file >> word;
186 
187  if( word != "GRT_DOUBLE_MOVING_AVERAGE_FILTER_FILE_V1.0" ){
188  errorLog << "loadModelFromFile(fstream &file) - Invalid file format!" << endl;
189  return false;
190  }
191 
192  //Load the number of input dimensions
193  file >> word;
194  if( word != "NumInputDimensions:" ){
195  errorLog << "loadModelFromFile(fstream &file) - Failed to read NumInputDimensions header!" << endl;
196  return false;
197  }
198  file >> numInputDimensions;
199 
200  //Load the number of output dimensions
201  file >> word;
202  if( word != "NumOutputDimensions:" ){
203  errorLog << "loadModelFromFile(fstream &file) - Failed to read NumOutputDimensions header!" << endl;
204  return false;
205  }
206  file >> numOutputDimensions;
207 
208  //Load the filter size
209  file >> word;
210  if( word != "FilterSize:" ){
211  errorLog << "loadModelFromFile(fstream &file) - Failed to read FilterSize header!" << endl;
212  return false;
213  }
214  file >> filterSize;
215 
216  //Init the filter module to ensure everything is initialized correctly
217  return init(filterSize,numInputDimensions);
218 }
219 
220 bool DoubleMovingAverageFilter::init(UINT filterSize,UINT numDimensions){
221 
222  //Cleanup the old memory
223  initialized = false;
224 
225  if( filterSize == 0 ){
226  errorLog << "init(UINT filterSize,UINT numDimensions) - Filter size can not be zero!" << endl;
227  return false;
228  }
229 
230  if( numDimensions == 0 ){
231  errorLog << "init(UINT filterSize,UINT numDimensions) - The number of dimensions must be greater than zero!" << endl;
232  return false;
233  }
234 
235  //Resize the filter
236  this->filterSize = filterSize;
237  numInputDimensions = numDimensions;
238  numOutputDimensions = numDimensions;
239  processedData.clear();
240  processedData.resize(numDimensions,0 );
241 
242  if( !filter1.init(filterSize, numDimensions) ){
243  errorLog << "init(UINT filterSize,UINT numDimensions) - Failed to initialize filter 1!" << endl;
244  return false;
245  }
246 
247  if( !filter2.init(filterSize, numDimensions) ){
248  errorLog << "init(UINT filterSize,UINT numDimensions) - Failed to initialize filter 1!" << endl;
249  return false;
250  }
251 
252  //Flag that the filter has been initialized
253  initialized = true;
254 
255  return true;
256 }
257 
258 double DoubleMovingAverageFilter::filter(const double x){
259 
260  //If the filter has not been initialised then return 0, otherwise filter x and return y
261  if( !initialized ){
262  errorLog << "filter(const double x) - The filter has not been initialized!" << endl;
263  return 0;
264  }
265 
266  VectorDouble y = filter(VectorDouble(1,x));
267 
268  if( y.size() == 0 ) return 0;
269  return y[0];
270 }
271 
272 VectorDouble DoubleMovingAverageFilter::filter(const VectorDouble &x){
273 
274  //If the filter has not been initialised then return 0, otherwise filter x and return y
275  if( !initialized ){
276  errorLog << "filter(const VectorDouble &x) - The filter has not been initialized!" << endl;
277  return VectorDouble();
278  }
279 
280  if( x.size() != numInputDimensions ){
281  errorLog << "filter(const VectorDouble &x) - The size of the input vector (" << x.size() << ") does not match that of the number of dimensions of the filter (" << numInputDimensions << ")!" << endl;
282  return VectorDouble();
283  }
284 
285  //Perform the first filter
286  VectorDouble y = filter1.filter( x );
287 
288  if( y.size() == 0 ) return y;
289 
290  //Perform the second filter
291  VectorDouble yy = filter2.filter( y );
292 
293  if( yy.size() == 0 ) return y;
294 
295  //Account for the filter lag
296  for(UINT i=0; i<y.size(); i++){
297  yy[i] = y[i] + (y[i] - yy[i]);
298  processedData[i] = yy[i];
299  }
300 
301  return yy;
302 }
303 
304 }//End of namespace GRT
Definition: AdaBoost.cpp:25
double filter(const double x)
virtual bool deepCopyFrom(const PreProcessing *preProcessing)
string getPreProcessingType() const
DoubleMovingAverageFilter(UINT filterSize=5, UINT numDimensions=1)
UINT filterSize
The size of the filter.
virtual bool process(const VectorDouble &inputVector)
MovingAverageFilter filter2
The second moving average filter.
DoubleMovingAverageFilter & operator=(const DoubleMovingAverageFilter &rhs)
bool copyBaseVariables(const PreProcessing *preProcessingModule)
virtual bool saveModelToFile(string filename) const
bool init(UINT filterSize, UINT numDimensions)
The class implements a double moving average filter.
virtual bool loadModelFromFile(string filename)
MovingAverageFilter filter1
The first moving average filter.